benchmarks/JetStream2/WSL/SPIR-V.js

/*
 * Copyright (C) 2017 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";

// This function accepts a JSON object describing the SPIR-V syntax.
// For example, https://github.com/KhronosGroup/SPIRV-Headers/blob/master/include/spirv/1.2/spirv.core.grammar.json
function SPIRV(json) {
    let result = {
        ops: {},
        kinds: {}
    }

    let composites = new Map();
    let ids = new Map();
    for (let kind of json.operand_kinds) {
        switch (kind.category) {
        case "BitEnum":
        case "ValueEnum":
            let enumerants = { category: kind.category };
            for (let enumerant of kind.enumerants) {
                enumerants[enumerant.enumerant] = enumerant;
            }
            result.kinds[kind.kind] = enumerants;
            break;
        case "Composite":
            composites.set(kind.kind, kind);
            break;
        case "Id":
            ids.set(kind.kind, kind);
            break;
        }
    }

    function matchType(operandInfoKind, operand) {
        switch (operandInfoKind) {
            // FIXME: I'm not actually sure that Ids should be unsigned.
            case "IdResultType":
            case "IdResult":
            case "IdRef":
            case "IdScope":
            case "IdMemorySemantics":
            case "LiteralExtInstInteger":
                if (typeof operand != "number")
                    throw new Error("Operand needs to be a number");
                if ((operand >>> 0) != operand)
                    throw new Error("Operand needs to fit in an unsigned int");
                return;
            case "LiteralInteger":
                if (typeof operand != "number")
                    throw new Error("Operand needs to be a number");
                if ((operand | 0) != operand)
                    throw new Error("Operand needs to fit in an int");
                return;
            case "LiteralString":
                if (typeof operand != "string")
                    throw new Error("Operand needs to be a string");
                return;
            case "LiteralContextDependentNumber":
            case "LiteralSpecConstantOpInteger":
                if (typeof operand != "number")
                    throw new Error("Operand needs to be a number");
                if ((operand >>> 0) != operand && (operand | 0) != operand)
                    throw new Error("Operand needs to fit in an unsigned int or an int.");
                return;
        }
        let kind = result.kinds[operandInfoKind];
        if (kind) {
            if (operand instanceof Array) {
                if (kind.category != "BitEnum")
                    throw new Error("Passing an array to a " + kind.category + " operand");
                for (let operandItem of operand) {
                    if (kind[operandItem.enumerant] != operandItem)
                        throw new Error("" + operandItem.enumerant + " is not a member of " + operandInfoKind);
                }
                return;
            }
            if (kind[operand.enumerant] != operand)
                throw new Error("" + operand.enumerant + " is not a member of " + operandInfoKind);
            return;
        }
        throw new Error("Unknown type: " + operandInfoKind);
    }

    class OperandChecker {
        constructor(operandInfos)
        {
            this._operandInfos = operandInfos || [];
            this._operandIndex = 0;
            this._operandInfoIndex = 0;
            this._parameters = [];
        }

        _isStar(operandInfo)
        {
            switch (operandInfo.kind) {
                case "LiteralContextDependentNumber":
                case "LiteralSpecConstantOpInteger":
                    // These types can be any width.
                    return true;
            }
            return operandInfo.quantifier && operandInfo.quantifier == "*";
        }

        nextComparisonType(operand)
        {
            if (this._operandInfoIndex >= this._operandInfos.length)
                throw new Error("Specified operand does not correspond to any that the instruction expects.");
            let operandInfo = this._operandInfos[this._operandInfoIndex];

            let isStar = this._isStar(operandInfo);

            if (this._parameters.length != 0) {
                let result = this._parameters[0];
                this._parameters.splice(0, 1);
                // FIXME: Handle parameters that require their own parameters
                ++this._operandIndex;
                if (this._parameters.length == 0 && !isStar)
                    ++this._operandInfoIndex;
                return result;
            }

            let composite = composites.get(operandInfo.kind);
            if (composite) {
                for (let base of composite.bases)
                    this._parameters.push(base);
                nextComparisonType(operand);
                return;
            }

            let kind = result.kinds[operandInfo.kind];
            if (kind) {
                let enumerant = kind[operand.enumerant];
                if (enumerant) {
                    let parameters = enumerant.parameters;
                    if (parameters) {
                        for (let parameter of parameters) {
                            this._parameters.push(parameter.kind);
                        }
                        ++this._operandIndex;
                        return operandInfo.kind;
                    }
                }
            }

            ++this._operandIndex;
            if (!isStar)
                ++this._operandInfoIndex;
            return operandInfo.kind;
        }

        check(operand)
        {
            matchType(this.nextComparisonType(operand), operand);
        }

        finalize()
        {
            if (this._parameters.length != 0)
                throw new Error("Operand not specified for parameter.");
            for (let i = this._operandInfoIndex; i < this._operandInfos.length; ++i) {
                let operandInfo = this._operandInfos[i];
                let quantifier = operandInfo.quantifier;
                if (quantifier != "?" && !this._isStar(operandInfo))
                    throw new Error("Did not specify operand " + i + " to instruction.");
            }
        }
    }

    for (let instruction of json.instructions) {
        if (!instruction.opname.startsWith("Op"))
            continue;
        let attributeName = instruction.opname.substring(2);
        result.ops[attributeName] = class {
            constructor(...operands)
            {
                let operandChecker = new OperandChecker(instruction.operands);
                for (let operand of operands)
                    operandChecker.check(operand);
                operandChecker.finalize();

                this._operands = operands;
            }
            get operands()
            {
                return this._operands;
            }
            get opname()
            {
                return instruction.opname;
            }
            get opcode()
            {
                return instruction.opcode;
            }
            get operandInfo()
            {
                return instruction.operands;
            }
            get storageSize()
            {
                let result = 1;
                for (let operand of this.operands) {
                    if (typeof operand == "number")
                        ++result;
                    else if (typeof operand == "string")
                        result += (((operand.length + 1) + 3) / 4) | 0;
                    else
                        ++result;
                }
                return result;
            }
            get largestId()
            {
                let maximumId = 0;
                let operandChecker = new OperandChecker(this.operandInfo);
                for (let operand of this.operands) {
                    let type = operandChecker.nextComparisonType(operand);
                    let idType = ids.get(type);
                    if (idType)
                        maximumId = Math.max(maximumId, operand);
                }
                return maximumId;
            }
        }
    }
    return result;
}

class SPIRVAssembler {
    constructor()
    {
        this._largestId = 0;
        this._size = 5;
        this._storage = new Uint32Array(this.size);
        this.storage[0] = 0x07230203; // Magic number
        this.storage[1] = 0x00010000; // Version: 1.0
        this.storage[2] = 0x574B0000; // Tool: "WK"
        this.storage[3] = 0; // Placeholder: All <id>s are less than this value.
        this.storage[4] = 0; // Reserved
    }

    append(op)
    {
        this._largestId = Math.max(this._largestId, op.largestId);

        let deltaStorageSize = op.storageSize;
        if (this.size + deltaStorageSize > this.storage.length) {
            let newStorageSize = (this.size + deltaStorageSize) * 1.5;
            let newStorage = new Uint32Array(newStorageSize);
            for (let i = 0; i < this.size; ++i)
                newStorage[i] = this.storage[i];
            this._storage = newStorage;
        }
        if ((deltaStorageSize & 0xFFFF) != deltaStorageSize || (op.opcode & 0xFFFF) != op.opcode)
            throw new Error("Out of bounds!");
        this.storage[this.size] = ((deltaStorageSize & 0xFFFF) << 16) | (op.opcode & 0xFFFF);
        ++this._size;
        if (deltaStorageSize <= op.operands.size)
            throw new Error("The storage size must be greater than the number of parameters");
        for (let i = 0; i < op.operands.length; ++i) {
            let operand = op.operands[i];
            if (typeof operand == "number") {
                this.storage[this.size] = operand;
                ++this._size;
            } else if (typeof operand == "string") {
                let word = 0;
                for (let j = 0; j < operand.length + 1; ++j) {
                    let charCode;
                    if (j < operand.length)
                        charCode = operand.charCodeAt(j);
                    else
                        charCode = 0;
                    if (charCode > 0xFF)
                        throw new Error("Non-ASCII strings don't work yet");
                    switch (j % 4) {
                    case 0:
                        word |= charCode;
                        break;
                    case 1:
                        word |= (charCode << 8);
                        break;
                    case 2:
                        word |= (charCode << 16);
                        break;
                    case 3:
                        word |= (charCode << 24);
                        this.storage[this.size + ((j / 4) | 0)] = word;
                        word = 0;
                        break;
                    }
                }
                if ((operand.length % 4) != 0)
                    this.storage[this.size + (((operand.length + 1) / 4) | 0)] = word;
                this._size += (((operand.length + 1) + 3) / 4) | 0;
            } else {
                this.storage[this.size] = operand.value;
                ++this._size;
            }
        }
    }

    get size()
    {
        return this._size;
    }

    get storage()
    {
        return this._storage;
    }

    get result()
    {
        this.storage[3] = this._largestId + 1;
        return this.storage.slice(0, this.size);
    }
}