CodeGenHelpers.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_CODEGENHELPERS_H
#define NVNEURAL_CODEGENHELPERS_H
 
#include <iosfwd>
#include <sstream>
#include <string>
#include <nvneural/CodeGenTypes.h>
 
namespace nvneural { namespace {
 
class SourceWriter
{
public:
    SourceWriter() = default;
    ~SourceWriter() = default;
 
    std::string str() const
    {
        return m_output;
    }
 
    void pushIndent(const std::string& indent)
    {
        m_indents.push_back(indent);
    }
 
    void popIndent()
    {
        m_indents.pop_back();
    }
 
    void writeFragment(const std::string& fragment)
    {
        std::string indentPrefix;
        for (const std::string& indent : m_indents)
        {
            indentPrefix += indent;
        }
        indentFragment(indentPrefix, fragment);
    }
 
    class Line
    {
        friend class SourceWriter;
    public:
        ~Line()
        {
            m_owner.writeFragment(m_stream.str());
        }
 
        template<typename TObject>
        Line& operator<<(TObject obj)
        {
            m_stream << obj;
            return *this;
        }
    private:
        explicit Line(SourceWriter& owner)
            : m_owner(owner)
        {
        }
        Line(const Line& copyFrom)
            : m_owner(copyFrom.m_owner)
            , m_stream()
        {
            // Not a true copy because ostringstream is noncopyable,
            // But C++14 builds need to do a single copy when the
            // SourceWriter::write() function returns. In this case,
            // we know that the stream hasn't been used yet so we'll
            // default-construct it instead.
        }
 
        SourceWriter& m_owner;
        std::ostringstream m_stream;
    };
 
    Line write()
    {
        return Line{*this};
    }
 
    class ScopedIndent
    {
        friend class SourceWriter;
    public:
        ~ScopedIndent()
        {
            m_owner.popIndent();
        }
    private:
        explicit ScopedIndent(SourceWriter& owner)
            : m_owner(owner)
        {
            m_owner.pushIndent("    ");
        }
        SourceWriter& m_owner;
    };
 
    ScopedIndent indent()
    {
        return ScopedIndent(*this);
    }
 
    class ScopedBraceBlock
    {
        friend class SourceWriter;
    public:
        ~ScopedBraceBlock()
        {
            m_owner.popIndent();
            m_owner.writeFragment("}" + m_suffix);
        }
    private:
        ScopedBraceBlock(SourceWriter& owner, const std::string& suffix)
            : m_owner(owner)
            , m_suffix(suffix)
        {
            m_owner.writeFragment("{");
            m_owner.pushIndent("    ");
        }
        SourceWriter& m_owner;
        std::string m_suffix;
    };
 
    ScopedBraceBlock brace(const std::string& suffix = "")
    {
        return ScopedBraceBlock(*this, suffix);
    }
 
private:
    std::string m_output;
    std::vector<std::string> m_indents;
 
    void indentFragment(const std::string& indent, const std::string& fragment)
    {
        std::string::size_type lineBegin = 0;
        std::string::size_type lineEnd;
        do
        {
            lineEnd = fragment.find('\n', lineBegin);
            const std::string line = fragment.substr(lineBegin, lineEnd - lineBegin);
            if (line.size())
            {
                m_output += indent;
                m_output += line;
            }
            m_output += "\n";
            lineBegin = lineEnd + 1;
        } while (lineEnd != std::string::npos);
    }
};
 
inline std::string generateTypeString(TensorDataType data)
{
    switch (data)
    {
    case TensorDataType::TestOnly:
        return "nvneural::TensorDataType::TestOnly";
    case TensorDataType::Float:
        return "nvneural::TensorDataType::Float";
    case TensorDataType::Half:
        return "nvneural::TensorDataType::Half";
    case TensorDataType::CompressedPng:
        return "nvneural::TensorDataType::CompressedPng";
    case TensorDataType::UncompressedRgb:
        return "nvneural::TensorDataType::UncompressedRgb";
    default:
        break;
    }
 
    return "unrecognizable type";
}
 
inline std::string generateTypeString(TensorDataLayout layout)
{
    switch (layout)
    {
    case TensorDataLayout::TestOnly:
        return "nvneural::TensorDataLayout::TestOnly";
    case TensorDataLayout::Nchw:
        return "nvneural::TensorDataLayout::Nchw";
    case TensorDataLayout::Nhwc:
        return "nvneural::TensorDataLayout::Nhwc";
 
    default:
        break;
    }
 
    return "unrecognizable layout";
}
 
inline std::string generateTypeString(NetworkBackendId backend)
{
    switch (backend)
    {
    case NetworkBackendId::TestOnly:
        return "nvneural::NetworkBackendId::TestOnly";
    case NetworkBackendId::Cpu:
        return "nvneural::NetworkBackendId::Cpu";
    case NetworkBackendId::Cuda:
        return "nvneural::NetworkBackendId::Cuda";
 
    default:
        break;
    }
 
    return "unrecognizable backend";
}
 
inline std::string floatToStr(float n)
{
    std::string s = std::to_string(n);
    if (s.find('.') == std::string::npos) // Did not find decimal point
    {
        s += ".";
    }
    s += "f";
    return s;
}
 
inline char toHex(int val)
{
    if(val<10) return '0'+val;
    return 'A'+val-10;
}
 
inline std::string toCppString(std::string str)
{
    std::string rv;
    for(size_t i=0;i<str.size();i++)
    {
        if(i+1 < str.size() && ((str[i]=='\n' && str[i+1]=='\r') || (str[i]=='\r' && str[i+1]=='\n')))
        {
            rv+="\\n";
            i++;
        }
        else if(str[i]=='\r' || str[i]=='\n')
        {
            rv+="\\n";
        }
        else if(str[i]=='\"')
        {
            rv+="\\\"";
        }
        else if(str[i]=='\\')
        {
            rv+="\\\\";
        }
        else if(str[i]<0x20 && str[i]!='\t')
        {
            rv+="\\x";
            rv.push_back(toHex((str[i]>>4)&0xf));
            rv.push_back(toHex(str[i]&0xf));
        }
        else
        {
            rv.push_back(str[i]);
        }
    }
    return rv;
}
 
inline std::vector<std::string> toCppStringLines(std::string str)
{
    std::vector<std::string> lines;
    std::string temp;
 
    for(size_t i=0;i<str.size();i++)
    {
        if(i+1 < str.size() && ((str[i]=='\n' && str[i+1]=='\r') || (str[i]=='\r' && str[i+1]=='\n')))
        {
            i++;
        }
        temp.push_back(str[i]);
        if(str[i]=='\r' || str[i]=='\n')
        {
            lines.push_back(toCppString(temp));
            temp.clear();
        }
    }
 
    lines.push_back(toCppString(temp));
 
    return lines;
}
}} // namespace nvneural::<anon>
 
#endif // NVNEURAL_CODEGENHELPERS_H