Changeset 4947 in CLRX


Ignore:
Timestamp:
Sep 4, 2019, 8:09:00 PM (2 weeks ago)
Author:
matszpk
Message:

CLRadeonExtender: ROCmBin: Write routines and classes to write MsgPack? data.

Location:
CLRadeonExtender/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/CLRX/amdbin/ROCmBinaries.h

    r4943 r4947  
    537537                    const ROCmKernelConfig** kconfigs, std::string& output);
    538538
     539void generateROCmMetadataMsgPack(const ROCmMetadata& mdInfo,
     540                    const ROCmKernelConfig** kconfigs, std::vector<cxbyte>& output);
     541
    539542void parseROCmMetadata(size_t metadataSize, const char* metadata,
    540543                ROCmMetadata& metadataInfo);
  • CLRadeonExtender/trunk/amdbin/ROCmMetadataMP.cpp

    r4946 r4947  
    982982}
    983983
     984static void msgPackWriteString(const char* str, std::vector<cxbyte>& output)
     985{
     986    const size_t len = ::strlen(str);
     987    if (len < 32)
     988        output.push_back(0xa0 + len);
     989    else if (len < 256)
     990    {
     991        cxbyte v[2];
     992        v[0] = 0xd9;
     993        v[1] = len;
     994        output.insert(output.end(), v, v+2);
     995    }
     996    else if (len < 0x10000U)
     997    {
     998        cxbyte v[3];
     999        v[0] = 0xda;
     1000        v[1] = len>>8;
     1001        v[2] = len&0xff;
     1002        output.insert(output.end(), v, v+3);
     1003    }
     1004    else
     1005    {
     1006        cxbyte v[5];
     1007        v[0] = 0xdb;
     1008        v[1] = len>>24;
     1009        v[2] = (len>>16)&0xff;
     1010        v[3] = (len>>8)&0xff;
     1011        v[4] = len&0xff;
     1012        output.insert(output.end(), v, v+5);
     1013    }
     1014    output.insert(output.end(), reinterpret_cast<const cxbyte*>(str),
     1015                  reinterpret_cast<const cxbyte*>(str+len));
     1016}
     1017
     1018static inline void msgPackWriteBool(bool b, std::vector<cxbyte>& output)
     1019{
     1020    output.push_back(b ? 0xc3 : 0xc2);
     1021}
     1022
     1023static void msgPackWriteUInt(uint64_t v, std::vector<cxbyte>& output)
     1024{
     1025    if (v < 128)
     1026        output.push_back(cxbyte(v));
     1027    else if (v < 256)
     1028    {
     1029        cxbyte d[2];
     1030        d[0] = 0xcc;
     1031        d[1] = cxbyte(v);
     1032        output.insert(output.end(), d, d+2);
     1033    }
     1034    else if (v < 0x10000U)
     1035    {
     1036        cxbyte d[3];
     1037        d[0] = 0xcd;
     1038        d[1] = v>>8;
     1039        d[2] = v&0xff;
     1040        output.insert(output.end(), d, d+3);
     1041    }
     1042    else if (v < 0x100000000ULL)
     1043    {
     1044        cxbyte d[5];
     1045        d[0] = 0xce;
     1046        uint64_t v2 = v;
     1047        for (cxuint i=5; i >= 0; i--, v2>>=8)
     1048            d[i] = v2&0xff;
     1049        output.insert(output.end(), d, d+5);
     1050    }
     1051    else
     1052    {
     1053        cxbyte d[9];
     1054        d[0] = 0xcf;
     1055        uint64_t v2 = v;
     1056        for (cxuint i=9; i >= 0; i--, v2>>=8)
     1057            d[i] = v2&0xff;
     1058        output.insert(output.end(), d, d+9);
     1059    }
     1060}
     1061
     1062class CLRX_INTERNAL MsgPackMapWriter;
     1063
     1064class CLRX_INTERNAL MsgPackArrayWriter
     1065{
     1066private:
     1067    std::vector<cxbyte>& output;
     1068    size_t elemsNum;
     1069    std::vector<cxbyte> temp;
     1070public:
     1071    MsgPackArrayWriter(std::vector<cxbyte>& output);
     1072   
     1073    void putBool(bool b);
     1074    void putString(const char* str);
     1075    void putUInt(uint64_t v);
     1076    MsgPackArrayWriter putArray();
     1077    MsgPackMapWriter putMap();
     1078    void flush();
     1079};
     1080
     1081class CLRX_INTERNAL MsgPackMapWriter
     1082{
     1083private:
     1084    std::vector<cxbyte>& output;
     1085    size_t elemsNum;
     1086    bool inKey;
     1087    std::vector<cxbyte> temp;
     1088public:
     1089    MsgPackMapWriter(std::vector<cxbyte>& output);
     1090    void putKeyString(const char* str);
     1091    void putValueBool(bool b);
     1092    void putValueString(const char* str);
     1093    void putValueUInt(uint64_t v);
     1094    MsgPackArrayWriter putValueArray();
     1095    MsgPackMapWriter putValueMap();
     1096    void flush();
     1097};
     1098
     1099MsgPackArrayWriter::MsgPackArrayWriter(std::vector<cxbyte>& _output)
     1100        : output(_output), elemsNum(0)
     1101{ }
     1102
     1103void MsgPackArrayWriter::putBool(bool b)
     1104{
     1105    elemsNum++;
     1106    msgPackWriteBool(b, temp);
     1107}
     1108
     1109void MsgPackArrayWriter::putString(const char* str)
     1110{
     1111    elemsNum++;
     1112    msgPackWriteString(str, temp);
     1113}
     1114
     1115void MsgPackArrayWriter::putUInt(uint64_t v)
     1116{
     1117    elemsNum++;
     1118    msgPackWriteUInt(v, temp);
     1119}
     1120
     1121MsgPackArrayWriter MsgPackArrayWriter::putArray()
     1122{
     1123    elemsNum++;
     1124    return MsgPackArrayWriter(temp);
     1125}
     1126
     1127void MsgPackArrayWriter::flush()
     1128{
     1129    if (elemsNum < 16)
     1130        output.push_back(0x90 + elemsNum);
     1131    else if (elemsNum < 0x10000U)
     1132    {
     1133        cxbyte d[3];
     1134        d[0] = 0xdc;
     1135        d[1] = elemsNum>>8;
     1136        d[2] = elemsNum&0xff;
     1137        output.insert(output.end(), d, d+3);
     1138    }
     1139    else
     1140    {
     1141        cxbyte d[5];
     1142        d[0] = 0xdd;
     1143        uint32_t v2 = elemsNum;
     1144        for (cxuint i=5; i >= 0; i--, v2>>=8)
     1145            d[i] = v2&0xff;
     1146        output.insert(output.end(), d, d+3);
     1147    }
     1148    output.insert(output.end(), temp.begin(), temp.end());
     1149}
     1150
     1151MsgPackMapWriter::MsgPackMapWriter(std::vector<cxbyte>& _output)
     1152        : output(_output), elemsNum(0), inKey(true)
     1153{ }
     1154
     1155void MsgPackMapWriter::putKeyString(const char* str)
     1156{
     1157    if (!inKey)
     1158        throw BinException("MsgPack: Not in key value");
     1159    inKey = false;
     1160    elemsNum++;
     1161    msgPackWriteString(str, temp);
     1162}
     1163
     1164void MsgPackMapWriter::putValueBool(bool b)
     1165{
     1166    if (inKey)
     1167        throw BinException("MsgPack: Not in value value");
     1168    inKey = true;
     1169    msgPackWriteBool(b, temp);
     1170}
     1171
     1172void MsgPackMapWriter::putValueString(const char* str)
     1173{
     1174    if (inKey)
     1175        throw BinException("MsgPack: Not in value value");
     1176    inKey = true;
     1177    msgPackWriteString(str, temp);
     1178}
     1179
     1180void MsgPackMapWriter::putValueUInt(uint64_t v)
     1181{
     1182    if (inKey)
     1183        throw BinException("MsgPack: Not in value value");
     1184    inKey = true;
     1185    msgPackWriteUInt(v, temp);
     1186}
     1187
     1188MsgPackArrayWriter MsgPackMapWriter::putValueArray()
     1189{
     1190    if (inKey)
     1191        throw BinException("MsgPack: Not in value value");
     1192    inKey = true;
     1193    return MsgPackArrayWriter(temp);
     1194}
     1195
     1196MsgPackMapWriter MsgPackMapWriter::putValueMap()
     1197{
     1198    if (inKey)
     1199        throw BinException("MsgPack: Not in value value");
     1200    inKey = true;
     1201    return MsgPackMapWriter(temp);
     1202}
     1203
     1204
    9841205void ROCmMetadata::parseMsgPack(size_t metadataSize, const cxbyte* metadata)
    9851206{
     
    9871208}
    9881209
     1210void CLRX::generateROCmMetadataMsgPack(const ROCmMetadata& mdInfo,
     1211                    const ROCmKernelConfig** kconfigs, std::vector<cxbyte>& output)
     1212{
     1213}
Note: See TracChangeset for help on using the changeset viewer.