Ignore:
Timestamp:
Aug 12, 2019, 9:23:11 AM (4 months ago)
Author:
matszpk
Message:

CLRadeonExtender: ROCm: Add first stuff to parse MsgPack? metadata. Amd3: Add some stuff to Amd3.

File:
1 edited

Legend:

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

    r4880 r4882  
    13411341{
    13421342    parseROCmMetadata(metadataSize, metadata, *this);
     1343}
     1344
     1345/*
     1346 * ROCm metadata MsgPack parser
     1347 */
     1348
     1349static void parseMsgPackNil(const cxbyte*& dataPtr, const cxbyte* dataEnd)
     1350{
     1351    if (dataPtr>=dataEnd || *dataPtr != 0xc0)
     1352        throw ParseException("MsgPack: Can't parse nil value");
     1353    dataPtr++;
     1354}
     1355
     1356static bool parseMsgPackBool(const cxbyte*& dataPtr, const cxbyte* dataEnd)
     1357{
     1358    if (dataPtr>=dataEnd || ((*dataPtr)&0xfe) != 0xc2)
     1359        throw ParseException("MsgPack: Can't parse bool value");
     1360    const bool v = (*dataPtr==0xc3);
     1361    dataPtr++;
     1362    return v;
     1363}
     1364
     1365enum: cxbyte {
     1366    MSGPACK_WS_UNSIGNED = 0,  // only unsigned
     1367    MSGPACK_WS_SIGNED = 1,  // only signed
     1368    MSGPACK_WS_BOTH = 2  // both signed and unsigned range checking
     1369};
     1370
     1371
     1372static uint64_t parseMsgPackInteger(const cxbyte*& dataPtr, const cxbyte* dataEnd,
     1373                cxbyte signess = MSGPACK_WS_BOTH)
     1374{
     1375    if (dataPtr>=dataEnd)
     1376        throw ParseException("MsgPack: Can't parse integer value");
     1377    uint64_t v = 0;
     1378    if (*dataPtr < 0x80)
     1379        v = *dataPtr++;
     1380    else if (*dataPtr >= 0xe0)
     1381        v = uint64_t(-32) + ((*dataPtr++) & 0x1f);
     1382    else
     1383    {
     1384        const cxbyte code = *dataPtr++;
     1385        switch(code)
     1386        {
     1387            case 0xcc:
     1388            case 0xd0:
     1389                if (dataPtr>=dataEnd)
     1390                    throw ParseException("MsgPack: Can't parse integer value");
     1391                v = *dataPtr++;
     1392                break;
     1393            case 0xcd:
     1394            case 0xd1:
     1395                if (dataPtr+1>=dataEnd)
     1396                    throw ParseException("MsgPack: Can't parse integer value");
     1397                v = *dataPtr++;
     1398                v |= uint32_t(*dataPtr++)<<8;
     1399                break;
     1400            case 0xce:
     1401            case 0xd2:
     1402                if (dataPtr+3>=dataEnd)
     1403                    throw ParseException("MsgPack: Can't parse integer value");
     1404                for (cxuint i = 0; i < 32; i+=8)
     1405                    v |= uint32_t(*dataPtr++)<<i;
     1406                break;
     1407            case 0xcf:
     1408            case 0xd3:
     1409                if (dataPtr+7>=dataEnd)
     1410                    throw ParseException("MsgPack: Can't parse integer value");
     1411                for (cxuint i = 0; i < 64; i+=8)
     1412                    v |= uint64_t(*dataPtr++)<<i;
     1413                break;
     1414            default:
     1415                throw ParseException("MsgPack: Can't parse integer value");
     1416        }
     1417       
     1418        if (signess == MSGPACK_WS_UNSIGNED && code >= 0xd0 && v >= (1ULL<<63))
     1419            throw ParseException("MsgPack: Negative value for unsigned integer");
     1420        if (signess == MSGPACK_WS_SIGNED && code < 0xd0 && v >= (1ULL<<63))
     1421            throw ParseException("MsgPack: Positive value out of range for signed integer");
     1422    }
     1423    return v;
     1424}
     1425
     1426static double parseMsgPackFloat(const cxbyte*& dataPtr, const cxbyte* dataEnd)
     1427{
     1428    if (dataPtr>=dataEnd)
     1429        throw ParseException("MsgPack: Can't parse float value");
     1430    const cxbyte code = *dataPtr++;
     1431    double vf = 0.0;
     1432    if (code == 0xca)
     1433    {
     1434        uint32_t v = 0;
     1435        if (dataPtr+3>=dataEnd)
     1436            throw ParseException("MsgPack: Can't parse float value");
     1437        for (cxuint i = 0; i < 32; i+=8)
     1438            v |= uint32_t(*dataPtr++)<<i;
     1439        vf = *reinterpret_cast<float*>(&v);
     1440    }
     1441    else if (code == 0xcb)
     1442    {
     1443        uint64_t v = 0;
     1444        if (dataPtr+7>=dataEnd)
     1445            throw ParseException("MsgPack: Can't parse float value");
     1446        for (cxuint i = 0; i < 64; i+=8)
     1447            v |= uint64_t(*dataPtr++)<<i;
     1448        vf = *reinterpret_cast<double*>(&v);
     1449    }
     1450    else
     1451        throw ParseException("MsgPack: Can't parse float value");
     1452    return vf;
     1453}
     1454
     1455static Array<cxbyte> parseMsgPackData(const cxbyte*& dataPtr, const cxbyte* dataEnd)
     1456{
     1457    if (dataPtr>=dataEnd)
     1458        throw ParseException("MsgPack: Can't parse byte-array");
     1459    const cxbyte code = *dataPtr++;
     1460    size_t size = 0;
     1461    switch (code)
     1462    {
     1463        case 0xc4:
     1464            if (dataPtr>=dataEnd)
     1465                throw ParseException("MsgPack: Can't parse byte-array size");
     1466            size = *dataPtr++;
     1467            break;
     1468        case 0xc5:
     1469            if (dataPtr+1>=dataEnd)
     1470                throw ParseException("MsgPack: Can't parse byte-array size");
     1471            size = *dataPtr++;
     1472            size |= uint32_t(*dataPtr++)<<8;
     1473            break;
     1474        case 0xc6:
     1475            if (dataPtr+3>=dataEnd)
     1476                throw ParseException("MsgPack: Can't parse byte-array size");
     1477            for (cxuint i = 0; i < 32; i+=8)
     1478                size |= uint32_t(*dataPtr++)<<i;
     1479            break;
     1480        default:
     1481            throw ParseException("MsgPack: Can't parse byte-array");
     1482    }
     1483   
     1484    Array<cxbyte> out(size);
     1485    if (dataPtr+size > dataEnd)
     1486        throw ParseException("MsgPack: Can't parse byte-array");
     1487    std::copy(dataPtr, dataPtr + size, out.begin());
     1488    dataPtr += size;
     1489    return out;
     1490}
     1491
     1492static void parseROCmMetadataMsgPack(size_t metadataSize, const cxbyte* metadata,
     1493                ROCmMetadata& metadataInfo)
     1494{
     1495    // init metadata info object
     1496    metadataInfo.kernels.clear();
     1497    metadataInfo.printfInfos.clear();
     1498    metadataInfo.version[0] = metadataInfo.version[1] = 0;
     1499   
     1500    std::vector<ROCmKernelMetadata>& kernels = metadataInfo.kernels;
     1501}
     1502
     1503void ROCmMetadata::parseMsgPack(size_t metadataSize, const cxbyte* metadata)
     1504{
     1505    parseROCmMetadataMsgPack(metadataSize, metadata, *this);
    13431506}
    13441507
Note: See TracChangeset for help on using the changeset viewer.