CoreHelpers.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.
*/
 
 
// Definitions in this file are not part of the version-safe ABI, but are provided as aids.
 
#ifndef NVNEURAL_COREHELPERS_H
#define NVNEURAL_COREHELPERS_H
 
#include <atomic>
#include <functional>
#include <string>
#include <typeinfo>
#include <type_traits>
#include <utility>
#include <nvneural/CoreTypes.h>
#include <nvneural/LayerTypes.h>
#include <nvneural/RefPtr.h>
 
namespace nvneural {
 
ILogger* DefaultLogger();
 
void SetDefaultLogger(ILogger* pDefaultLogger);
 
enum class TensorDimensionParseOrder : std::uint32_t
{
    Tensor = 0,
 
    Image  = 1,
 
    // When porting older code, a trailing ", true" in the tensorDim parse call means Image/whcn mode.
};
 
NeuralResult TensorDimensionFromString(TensorDimension& outDim, const std::string& dimStr, TensorDimensionParseOrder parseOrder, size_t fillValue) noexcept;
 
std::string TensorDimensionToString(const TensorDimension& dim) noexcept;
 
inline TensorDimension align(const TensorDimension& dim, const TensorDimension& stepping) noexcept
{
    const auto alignComponent = [](size_t x, size_t y) -> size_t { return ((x + y - 1) / y) * y; };
    const TensorDimension result
    {
        alignComponent(dim.n, stepping.n),
        alignComponent(dim.c, stepping.c),
        alignComponent(dim.h, stepping.h),
        alignComponent(dim.w, stepping.w),
    };
    return result;
}
 
template<typename TDividend, typename TDivisor>
inline auto constexpr DivideRoundingUp(TDividend dividend, TDivisor divisor) noexcept
{
    return ((dividend + divisor - TDivisor{1}) / divisor);
}
 
inline constexpr std::size_t dataSize(TensorDataType dataType) noexcept
{
    switch (dataType)
    {
        case TensorDataType::Float:   return sizeof(float);
        case TensorDataType::Half:    return sizeof(Float16);
        default:
            return 0;
    }
}
 
inline std::vector<std::string> split(std::string strToSplit, char delimiter, bool skip_empty = false)
{
    std::vector<std::string> splitStrings;
    size_t j = 0;
    for(size_t i = 0; i < strToSplit.size(); i++)
    {
        if(strToSplit[i] == delimiter)
        {
            if(!skip_empty || (i - j))
            {
                splitStrings.push_back(strToSplit.substr(j, i - j));
            }
            j = i + 1;
        }
 
        if(i == strToSplit.size() - 1)
        {
            if(!skip_empty || (strToSplit.size() - j))
            {
                splitStrings.push_back(strToSplit.substr(j, strToSplit.size() - j));
            }
        }
    }
    return splitStrings;
}
 
inline std::vector<std::string> splitEscape(std::string strToSplit, char delimiter, bool skip_empty = false)
{
    std::vector<std::string> splitStrings;
 
    std::string buildString;
    bool lastCharEscape = false;
    for (size_t newSplitNdx = 0; newSplitNdx < strToSplit.size(); newSplitNdx++)
    {
        if ((strToSplit[newSplitNdx] == '\\') && (!lastCharEscape))
        {
            lastCharEscape = true; 
        }
        else
        {
            if ((strToSplit[newSplitNdx] == delimiter) && (!lastCharEscape))
            {
                if (!skip_empty || !buildString.empty())
                {
                    splitStrings.push_back(buildString);
                    buildString.clear();
                }
            }
            else
            {
                try
                {
                    buildString += strToSplit[newSplitNdx];
                }
                catch (const std::exception& ex)
                {
                    DefaultLogger()->logWarning(0, "Splitting string problem: %s : %s", buildString.c_str(), ex.what());
                    return splitStrings;
                }
                lastCharEscape = false;
            }
        }
    }
 
    if (!skip_empty || !buildString.empty())
    {
        splitStrings.push_back(buildString);
        buildString.clear();
    }
 
    return splitStrings;
}
 
inline NeuralResult getInputLayerIndex(ILayer* pLayer, ILayer* pInputLayer, size_t* pIndex)
{
    RefPtr<ILayerList> pInputList;
    const auto status = pLayer->getInputLayers(pInputList.put());
    if (failed(status))
    {
        return status;
    }
    for (size_t index = 0; index < pInputList->layerCount(); ++index)
    {
        const auto pInput = pInputList->getLayerByIndex(index);
        if (pInput == pInputLayer)
        {
            *pIndex = index;
            return NeuralResult::Success;
        }
    }
 
    return NeuralResult::Failure;
}
 
} // namespace nvneural
 
namespace std {
 
template<> struct hash<nvneural::NetworkBackendId>
{
    std::size_t operator ()(nvneural::NetworkBackendId backendId) const noexcept
    {
        return std::hash<uint32_t>()(static_cast<std::uint32_t>(backendId));
    }
};
 
} // namespace std
 
// compat: RefObjectBase and friends moved to a different header
#include <nvneural/RefObject.h>
 
#endif // NVNEURAL_COREHELPERS_H