ScriptEngine.h

Go to the documentation of this file.

/*
* SPDX-FileCopyrightText: Copyright (c) 2020-2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
 
 
#ifndef NVNEURAL_SCRIPTENGINE_H
#define NVNEURAL_SCRIPTENGINE_H
 
#include <nvneural/CoreTypes.h>
#include "ScriptEngineAnyOp.h"
#include "ScriptEngineLexyn.h"
#include "ScriptEngineUtils.h"
#include <string>
#include <map>
 
namespace nvneural {
namespace detail {
 
template <class T>
class ScriptInterpretInterface
{
public:
 
    virtual ~ScriptInterpretInterface()
    {
    }
 
    virtual void setReal(T& v, const std::string& str) = 0;
    virtual void setInteger(T& v, const std::string& str) = 0;
    virtual void setBufferPointer(T& v, const std::string& str, int argIndex) = 0;
 
    virtual void neg(T& v) = 0;
    virtual void add(T& v, T& op) = 0;
    virtual void sub(T& v, T& op) = 0;
    virtual void mul(T& v, T& op) = 0;
    virtual void div(T& v, T& op) = 0;
 
    virtual void setRealOption(T& v, const std::string& str) = 0;
    virtual void setIntegerOption(T& v, const std::string& str) = 0;
 
    virtual void transform(T& v, const std::string& str) = 0;
 
    virtual void setActType(T& v) = 0;
    virtual void setActAlhpaLeft(T& v) = 0;
    virtual void setActAlhpaRight(T& v) = 0;
 
    virtual void setWeightsPointer(T& v, const std::string& str) = 0;
 
    virtual void setInputPointer(T& v, int index) = 0;
    virtual void setInputDimValue(T& v, int index, const std::string& str) = 0;
 
    virtual void setOutputPointer(T& v, const std::string& name) = 0;
    virtual void setOutputDimValue(T& v, const std::string& name, const std::string& str) = 0;
};
 
struct ScriptEngineParameters
{
    std::string name; 
    std::string type; 
    int numberOfInputs; 
    std::map<std::string, std::string> code; //tensor type as a key
    //dim example: 1,in[0].c+in[1].c,in.h,in.w;... (without index mean in[0].h == in[1].h == in[2].h ...)
    std::string dimNCHWCalculation;
    //fwd example: calling_kernel_name(in[0],in[1],out.w,out.h,in[0].c,in[1].c,out,1+5*4,act,act.alpha,@option,parameter)
    std::map<std::string, std::string> fwdEvalCall;
    //parameters from XML (and also fused parameters, for example: _0_parameter, where 0 is index of layer in order of fusing)
    std::map<std::string, std::string> parameters;
    std::vector<std::string> optionLegends; //for UI
    std::vector<std::string> outputList; //additional outputs
    //weights for layer, example: {{"kernel","1,in.c,1,1"},{"kernel.internal","1,((in.c+7)/8)*8,1,1}}
    //key - weights name, value - expression like in dim, see WDimInfoType for modifiers, default will be applied for not listed
    std::map<std::string, std::string> weights;
    std::vector<std::string> orderedWeightsNames;
};
 
class ScriptEngine : public ScriptInterpretInterface<std::string>, public ScriptInterpretInterface<AnyOperand>
{
public:
    explicit ScriptEngine(const ScriptEngineParameters& engineParameters);
    virtual ~ScriptEngine() override
    {
    }
 
    const std::map<std::string, std::string>& code() const;
    const std::vector<std::string>& outputList() const;
    const std::map<std::string, std::string>& weights() const;
    const std::vector<std::string>& orderedWeightsNames() const;
 
    const std::map<std::string, std::string>& parameters() const;
    const std::map<std::string, Lexem>& parametersParsed() const;
    const std::vector<std::string>& optionLegends() const;
    std::map<std::string, std::string>& optionValues();
    const std::string& optionType(const std::string& name) const;
 
    const SynParser::Node& fwdSyntree(const std::string& id) const;
    const std::string& entry(const std::string& id) const;
    const std::vector<AnyOperand>& ops(const std::string& id) const;
    const TensorDimension& stepping(const std::string& id) const;
    const std::string& fwdEvalCall(const std::string& id) const;
 
    const std::string& dimNchwCalculation() const;
    const std::vector<SynParser::Node>& dimSyntree() const;
 
    std::map<int, std::vector<uint8_t>>& bufferArgs();
 
    bool cudaExists() const;
    bool cubinExists() const;
    bool dxmlExists() const;
    bool csExists() const;
 
    bool actInternal() const;
 
    template <class T>
    T interpretParameter(ScriptInterpretInterface<T>* pInterpret, const SynParser::Node& node, bool call, int argIndex = -1)
    {
        T rv;
 
        switch (node.lex.type)
        {
        case Lexem::FLOAT:
            if (call)
            {
                pInterpret->setReal(rv, node.lex.value);
            }
            break;
        case Lexem::INTEGER:
            pInterpret->setInteger(rv, node.lex.value);
            break;
        case Lexem::STRING:
            if (argIndex >= 0 && call)
            {
                pInterpret->setBufferPointer(rv, node.lex.value, argIndex);
            }
            break;
        case Lexem::GRAMMAR:
            if (node.lex.value == "UNAR")
            {
                rv = interpretParameter<T>(pInterpret, node.child[1], call);
                pInterpret->neg(rv);
            }
            else if (node.lex.value == "ADDSUB" || node.lex.value == "MULDIV")
            {
                rv = interpretParameter<T>(pInterpret, node.child[0], call);
                for (size_t i = 1; i < node.child.size(); i += 2)
                {
                    T op = interpretParameter<T>(pInterpret, node.child[i + 1], call);
                    if (node.child[i].lex.value == "+")
                        pInterpret->add(rv, op);
                    else if (node.child[i].lex.value == "-")
                        pInterpret->sub(rv, op);
                    else if (node.child[i].lex.value == "*")
                        pInterpret->mul(rv, op);
                    else if (node.child[i].lex.value == "/")
                        pInterpret->div(rv, op);
                }
            }
            else if (node.lex.value == "OPTION")
            {
                if (call)
                {
                    if (m_optionType[node.child[0].lex.value] == "float")
                    {
                        pInterpret->setRealOption(rv, node.child[0].lex.value);
                    }
                    else
                    {
                        pInterpret->setIntegerOption(rv, node.child[0].lex.value);
                    }
                }
            }
            else if (node.lex.value == "CALL")
            {
                if (node.child.size() == 2 && call)
                {
                    rv = interpretParameter<T>(pInterpret, node.child[1], call);
                    pInterpret->transform(rv, node.child[0].lex.value);
                }
            }
            else if (node.lex.value == "VAR")
            {
                bool dual_id = node.child.size() > 1;
                std::string id = node.child[0].child[0].lex.value;
                std::string second_id;
                if (dual_id)
                    second_id = node.child[1].child[0].lex.value;
                bool has_index = node.child[0].child.size() > 1;
                int index = has_index ? std::atoi(node.child[0].child[1].lex.value.c_str()) : 0;
 
                if (id == "act")
                {
                    if (dual_id)
                    {
                        if ((second_id == "alpha" || second_id == "alpha_left") && call)
                            pInterpret->setActAlhpaLeft(rv);
                        else if (second_id == "alpha_right" && call)
                            pInterpret->setActAlhpaRight(rv);
                    }
                    else
                    {
                        pInterpret->setActType(rv);
                    }
                    m_actInternal = true;
                }
                else if (id == "weights" && dual_id)
                {
                    pInterpret->setWeightsPointer(rv, second_id);
                }
                else if (id == "in") //input
                {
                    if (dual_id || has_index)
                    {
                        if (has_index)
                        {
                            if (!dual_id)
                            {
                                if (call)
                                {
                                    pInterpret->setInputPointer(rv, index);
                                }
                            }
                            else
                            {
                                pInterpret->setInputDimValue(rv, index, second_id);
                            }
                        }
                        else if (dual_id)
                        {
                            pInterpret->setInputDimValue(rv, -1, second_id);
                        }
                    }
                    else if (call)
                    {
                        pInterpret->setInputPointer(rv, -1);
                    }
                }
                else if (indexOf(m_outputList, id) >= 0 && call)
                {
                    if (!dual_id)
                    {
                        pInterpret->setOutputPointer(rv, id);
                    }
                    else
                    {
                        pInterpret->setOutputDimValue(rv, id, second_id);
                    }
                }
                else if (id == "out" && call) //tensor
                {
                    if (!dual_id)
                    {
                        pInterpret->setOutputPointer(rv, "");
                    }
                    else if (has_index)
                    {
                        if (index < int(m_outputList.size()))
                        {
                            pInterpret->setOutputDimValue(rv, m_outputList[index], second_id);
                        }
                    }
                    else
                    {
                        pInterpret->setOutputDimValue(rv, "", second_id);
                    }
                }
                else if (m_parameters.find(id) != m_parameters.end())
                {
                    if (m_parametersParsed[id].type == Lexem::INTEGER)
                    {
                        pInterpret->setInteger(rv, m_parametersParsed[id].value);
                    }
                    else if (m_parametersParsed[id].type == Lexem::FLOAT && call)
                    {
                        pInterpret->setReal(rv, m_parametersParsed[id].value);
                    }
                    else if (m_parametersParsed[id].type == Lexem::DIMENSION && dual_id)
                    {
                        std::vector<std::string> dim = split(m_parametersParsed[id].value, 'x', false);
                        for (size_t i = dim.size(); i < 3; i++)
                        {
                            dim.push_back("1");
                        }
                        if (second_id == "x")
                        {
                            pInterpret->setInteger(rv, dim[0]);
                        }
                        else if (second_id == "y")
                        {
                            pInterpret->setInteger(rv, dim[1]);
                        }
                        else if (second_id == "z")
                        {
                            pInterpret->setInteger(rv, dim[2]);
                        }
                    }
                }
            }
            break;
        default:
            break;
        };
 
        return rv;
    }
 
    void setReal(AnyOperand& v, const std::string& /*str*/) override;
    void setInteger(AnyOperand& v, const std::string& /*str*/) override;
    void setBufferPointer(AnyOperand& v, const std::string& str, int argIndex) override;
    void neg(AnyOperand& v) override;
    void add(AnyOperand& v, AnyOperand& op) override;
    void sub(AnyOperand& v, AnyOperand& op) override;
    void mul(AnyOperand& v, AnyOperand& op) override;
    void div(AnyOperand& v, AnyOperand& op) override;
    void setRealOption(AnyOperand& v, const std::string& /*str*/) override;
    void setIntegerOption(AnyOperand& v, const std::string& /*str*/) override;
    void transform(AnyOperand& v, const std::string& str) override;
    void setActType(AnyOperand& v) override;
    void setActAlhpaLeft(AnyOperand& v) override;
    void setActAlhpaRight(AnyOperand& v) override;
    void setWeightsPointer(AnyOperand& v, const std::string& str) override;
    void setInputPointer(AnyOperand& v, int index) override;
    void setInputDimValue(AnyOperand& v, int index, const std::string& str) override;
    void setOutputPointer(AnyOperand& v, const std::string& name) override;
    void setOutputDimValue(AnyOperand& v, const std::string& name, const std::string& str) override;
 
    std::string generateParameter(const SynParser::Node& node, bool call, const std::string& pointerCast, bool inPlugin, int argIndex);
 
    void setReal(std::string& v, const std::string& str) override;
    void setInteger(std::string& v, const std::string& str) override;
    void setBufferPointer(std::string& v, const std::string& str, int argIndex) override;
    void neg(std::string& v) override;
    void add(std::string& v, std::string& op) override;
    void sub(std::string& v, std::string& op) override;
    void mul(std::string& v, std::string& op) override;
    void div(std::string& v, std::string& op) override;
    void setRealOption(std::string& v, const std::string& str) override;
    void setIntegerOption(std::string& v, const std::string& str) override;
    void transform(std::string& v, const std::string& str) override;
    void setActType(std::string& v) override;
    void setActAlhpaLeft(std::string& v) override;
    void setActAlhpaRight(std::string& v) override;
    void setWeightsPointer(std::string& v, const std::string& str) override;
    void setInputPointer(std::string& v, int index) override;
    void setInputDimValue(std::string& v, int index, const std::string& str) override;
    void setOutputPointer(std::string& v, const std::string& name) override;
    void setOutputDimValue(std::string& v, const std::string& name, const std::string& str) override;
 
    void setActFused();
 
protected:
 
    bool m_inPlugin;
    std::string m_pointerCast;
 
    std::string m_name;
    std::string m_type;
 
    bool m_actInternal = false;
 
    bool m_cudaCodeExists = false;
    bool m_cubinCodeExists = false;
    bool m_dxmlCodeExists = false;
    bool m_csCodeExists = false;
 
    int m_numberOfInputs;
 
    std::map<std::string, std::string> m_code;
 
    std::string m_dimNCHWCalculation;
    std::map<std::string, std::string> m_fwdEvalCall;
 
    std::map<std::string, std::string> m_parameters;
    std::vector<std::string> m_optionLegends;
    std::map<std::string, std::string> m_optionType;
    std::map<std::string, std::string> m_optionValues;
 
    std::map<std::string, Lexem> m_parametersParsed;
 
    std::map<std::string, SynParser::Node> m_fwdSyntreeAll;
    std::vector<SynParser::Node> m_dimSyntree;
    SynParser m_parser;
 
    bool m_genCheckN = false;
    bool m_genCheckC = false;
    bool m_genCheckH = false;
    bool m_genCheckW = false;
 
    std::vector<std::string> m_outputList;
 
    std::map<std::string, std::vector<AnyOperand> > m_opsAll;
    std::map<std::string, std::string> m_entryAll;
    std::map<int, std::vector<uint8_t>> m_bufferArgs;
 
    std::map<std::string, std::string> m_weights;
    std::map<std::string, SynParser::Node> m_weightsSyntree;
    std::vector<std::string> m_orderedWeightsNames;
 
    std::map<std::string, TensorDimension> m_steppingValueAll;
};
 
} // namespace detail
} // namespace nvneural
 
#endif // !NVNEURAL_SCRIPTENGINE_H