Changeset 4893 in CLRX


Ignore:
Timestamp:
Aug 14, 2019, 1:48:44 PM (5 days ago)
Author:
matszpk
Message:

CLRadeonExtender: ROCm: Use std::string in parseMsgPackString and in other routines to parse MsgPack? string. Add stuff to parse kernel argument info. Fix parsing access qualifier for kernel arginfo in YAML parser.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/amdbin/ROCmMetadata.cpp

    r4892 r4893  
    12481248                                    ptr, end, lineNo, level, true));
    12491249                    size_t accIndex = 0;
    1250                     for (; accIndex < 6; accIndex++)
     1250                    for (; accIndex < 4; accIndex++)
    12511251                        if (::strcmp(rocmAccessQualifierTbl[accIndex], acc.c_str())==0)
    12521252                            break;
     
    12651265                    size_t aspaceIndex = 0;
    12661266                    for (; aspaceIndex < 6; aspaceIndex++)
    1267                         if (::strcmp(rocmAddrSpaceTypesTbl[aspaceIndex],
     1267                        if (::strcasecmp(rocmAddrSpaceTypesTbl[aspaceIndex],
    12681268                                    aspace.c_str())==0)
    12691269                            break;
     
    14571457}
    14581458
    1459 static CString parseMsgPackString(const cxbyte*& dataPtr, const cxbyte* dataEnd)
     1459static std::string parseMsgPackString(const cxbyte*& dataPtr, const cxbyte* dataEnd)
    14601460{
    14611461    if (dataPtr>=dataEnd)
     
    14951495        throw ParseException("MsgPack: Can't parse string");
    14961496    const char* strData = reinterpret_cast<const char*>(dataPtr);
    1497     CString out(strData, strData + size);
     1497    std::string out(strData, strData + size);
    14981498    dataPtr += size;
    14991499    return out;
     
    16651665    uint64_t parseInteger(cxbyte signess);
    16661666    double parseFloat();
    1667     CString parseString();
     1667    std::string parseString();
    16681668    Array<cxbyte> parseData();
    16691669    MsgPackArrayParser parseArray();
     
    16901690    uint64_t parseKeyInteger(cxbyte signess);
    16911691    double parseKeyFloat();
    1692     CString parseKeyString();
     1692    std::string parseKeyString();
    16931693    Array<cxbyte> parseKeyData();
    16941694    MsgPackArrayParser parseKeyArray();
     
    16981698    uint64_t parseValueInteger(cxbyte signess);
    16991699    double parseValueFloat();
    1700     CString parseValueString();
     1700    std::string parseValueString();
    17011701    Array<cxbyte> parseValueData();
    17021702    MsgPackArrayParser parseValueArray();
     
    17771777}
    17781778
    1779 CString MsgPackArrayParser::parseString()
     1779std::string MsgPackArrayParser::parseString()
    17801780{
    17811781    handleErrors();
     
    18801880}
    18811881
    1882 CString MsgPackMapParser::parseKeyString()
     1882std::string MsgPackMapParser::parseKeyString()
    18831883{
    18841884    handleErrors(true);
     
    19381938}
    19391939
    1940 CString MsgPackMapParser::parseValueString()
     1940std::string MsgPackMapParser::parseValueString()
    19411941{
    19421942    handleErrors(false);
     
    20222022                sizeof(rocmMetadataMPKernelArgNames) / sizeof(const char*);
    20232023
     2024static const char* rocmMPAccessQualifierTbl[] =
     2025{ "read_only", "write_only", "read_write" };
     2026
    20242027static void parseROCmMetadataKernelArgMsgPack(MsgPackArrayParser& argsParser,
    20252028                        ROCmKernelArgInfo& argInfo)
     
    20282031    while (aParser.haveElements())
    20292032    {
    2030         const CString name = aParser.parseKeyString();
     2033        const std::string name = aParser.parseKeyString();
    20312034        const size_t index = binaryFind(rocmMetadataMPKernelArgNames,
    20322035                    rocmMetadataMPKernelArgNames + rocmMetadataMPKernelArgNamesSize,
     
    20352038        {
    20362039            case ROCMMP_ARG_ACCESS:
    2037                 break;
    20382040            case ROCMMP_ARG_ACTUAL_ACCESS:
    2039                 break;
     2041            {
     2042                const std::string acc = trimStrSpaces(aParser.parseValueString());
     2043                size_t accIndex = 0;
     2044                for (; accIndex < 3; accIndex++)
     2045                    if (::strcmp(rocmMPAccessQualifierTbl[accIndex], acc.c_str())==0)
     2046                        break;
     2047                if (accIndex == 3)
     2048                    throw ParseException("Wrong access qualifier");
     2049                if (index == ROCMMP_ARG_ACCESS)
     2050                    argInfo.accessQual = ROCmAccessQual(accIndex+1);
     2051                else
     2052                    argInfo.actualAccessQual = ROCmAccessQual(accIndex+1);
     2053                break;
     2054            }
    20402055            case ROCMMP_ARG_ADDRESS_SPACE:
    2041                 break;
     2056            {
     2057                const std::string aspace = trimStrSpaces(aParser.parseValueString());
     2058                size_t aspaceIndex = 0;
     2059                for (; aspaceIndex < 6; aspaceIndex++)
     2060                    if (::strcasecmp(rocmAddrSpaceTypesTbl[aspaceIndex],
     2061                                aspace.c_str())==0)
     2062                        break;
     2063                if (aspaceIndex == 6)
     2064                    throw ParseException("Wrong address space");
     2065                argInfo.addressSpace = ROCmAddressSpace(aspaceIndex+1);
     2066                break;
     2067            }
    20422068            case ROCMMP_ARG_IS_CONST:
     2069                argInfo.isConst = aParser.parseValueBool();
    20432070                break;
    20442071            case ROCMMP_ARG_IS_PIPE:
     2072                argInfo.isPipe = aParser.parseValueBool();
    20452073                break;
    20462074            case ROCMMP_ARG_IS_RESTRICT:
     2075                argInfo.isRestrict = aParser.parseValueBool();
    20472076                break;
    20482077            case ROCMMP_ARG_IS_VOLATILE:
     2078                argInfo.isVolatile = aParser.parseValueBool();
    20492079                break;
    20502080            case ROCMMP_ARG_NAME:
     2081                argInfo.name = aParser.parseValueString();
    20512082                break;
    20522083            case ROCMMP_ARG_OFFSET:
     2084                argInfo.offset = aParser.parseValueInteger(MSGPACK_WS_UNSIGNED);
    20532085                break;
    20542086            case ROCMMP_ARG_POINTEE_ALIGN:
     2087                argInfo.pointeeAlign = aParser.parseValueInteger(MSGPACK_WS_UNSIGNED);
    20552088                break;
    20562089            case ROCMMP_ARG_SIZE:
     2090                argInfo.size = aParser.parseValueInteger(MSGPACK_WS_UNSIGNED);
    20572091                break;
    20582092            case ROCMMP_ARG_TYPE_NAME:
     2093                argInfo.typeName = aParser.parseValueString();
    20592094                break;
    20602095            case ROCMMP_ARG_VALUE_KIND:
    2061                 break;
     2096            {
     2097                const std::string vkind = trimStrSpaces(aParser.parseValueString());
     2098                const size_t vkindIndex = binaryMapFind(rocmValueKindNamesMap,
     2099                            rocmValueKindNamesMap + rocmValueKindNamesNum, vkind.c_str(),
     2100                            CStringLess()) - rocmValueKindNamesMap;
     2101                    // if unknown kind
     2102                    if (vkindIndex == rocmValueKindNamesNum)
     2103                        throw ParseException("Wrong argument value kind");
     2104                    argInfo.valueKind = rocmValueKindNamesMap[vkindIndex].second;
     2105                break;
     2106            }
    20622107            case ROCMMP_ARG_VALUE_TYPE:
    2063                 break;
     2108            {
     2109                const std::string vtype = trimStrSpaces(aParser.parseValueString());
     2110                const size_t vtypeIndex = binaryMapFind(rocmValueTypeNamesMap,
     2111                        rocmValueTypeNamesMap + rocmValueTypeNamesNum, vtype.c_str(),
     2112                        CStringLess()) - rocmValueTypeNamesMap;
     2113                // if unknown type
     2114                if (vtypeIndex == rocmValueTypeNamesNum)
     2115                    throw ParseException("Wrong argument value type");
     2116                argInfo.valueType = rocmValueTypeNamesMap[vtypeIndex].second;
     2117                break;
     2118            }
    20642119            default:
    20652120                aParser.skipValue();
     
    21002155    while (kParser.haveElements())
    21012156    {
    2102         const CString name = kParser.parseKeyString();
     2157        const std::string name = kParser.parseKeyString();
    21032158        const size_t index = binaryFind(rocmMetadataMPKernelNames,
    21042159                    rocmMetadataMPKernelNames + rocmMetadataMPKernelNamesSize,
Note: See TracChangeset for help on using the changeset viewer.