Changeset 4123 in CLRX


Ignore:
Timestamp:
May 9, 2018, 9:07:22 AM (2 weeks ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Deduplicate code for checking varCallMap and varRoutineMap. Add next testcase with routines.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/tests/amdasm/AsmRegAlloc3.cpp

    r4122 r4123  
    995995        s_setpc_b64 s[0:1]              # 52
    996996)ffDXD",
    997         {
     997        {   // livenesses
    998998            {   // for SGPRs
    999999                { { 29, 32 }, { 44, 53 } }, // 0: S0
     
    10541054        s_setpc_b64 s[0:1]              # 84
    10551055)ffDXD",
    1056         {
     1056        {   // livenesses
    10571057            {   // for SGPRs
    10581058                { { 33, 36 }, { 52, 73 }, { 76, 85 } }, // 0: S0
     
    10861086        },
    10871087        true, ""
     1088    },
     1089    {   // 19 - simple call, more complex routine
     1090        R"ffDXD(.regvar sa:s:8, va:v:8
     1091        s_mov_b32 sa[2], s4             # 0
     1092        s_mov_b32 sa[3], s5             # 4
     1093        s_mov_b32 sa[5], s5             # 8
     1094       
     1095        s_getpc_b64 s[2:3]              # 12
     1096        s_add_u32 s2, s2, routine-.     # 16
     1097        s_add_u32 s3, s3, routine-.+4   # 24
     1098        .cf_call routine
     1099        s_swappc_b64 s[0:1], s[2:3]     # 32
     1100       
     1101        s_lshl_b32 sa[2], sa[2], 3      # 36
     1102        s_lshl_b32 sa[3], sa[3], sa[5]  # 40
     1103        s_endpgm                        # 44
     1104       
     1105routine:
     1106        s_xor_b32 sa[2], sa[2], sa[4]   # 48
     1107        s_cbranch_scc1 bb1              # 52
     1108       
     1109        s_min_u32 sa[2], sa[2], sa[4]   # 56
     1110        s_xor_b32 sa[3], sa[3], sa[4]   # 60
     1111        .cf_ret
     1112        s_setpc_b64 s[0:1]              # 64
     1113       
     1114bb1:    s_and_b32 sa[2], sa[2], sa[4]   # 68
     1115        .cf_ret
     1116        s_setpc_b64 s[0:1]              # 72
     1117)ffDXD",
     1118        {   // livenesses
     1119            {   // for SGPRs
     1120                { { 33, 36 }, { 48, 65 }, { 68, 73 } }, // 0: S0
     1121                { { 33, 36 }, { 48, 65 }, { 68, 73 } }, // 1: S1
     1122                { { 13, 33 } }, // 2: S2
     1123                { { 13, 33 } }, // 3: S3
     1124                { { 0, 1 } }, // 4: S4
     1125                { { 0, 9 } }, // 5: S5
     1126                { { 1, 36 }, { 48, 49 } }, // 6: sa[2]'0
     1127                { { 49, 57 }, { 68, 69 } }, // 7: sa[2]'1
     1128                { { 36, 37 }, { 57, 68 }, { 69, 76 } }, // 8: sa[2]'2
     1129                { { 37, 38 } }, // 9: sa[2]'3
     1130                { { 5, 41 }, { 48, 62 } }, // 10: sa[3]'0
     1131                { { 41, 42 } }, // 11: sa[3]'1
     1132                { { 0, 36 }, { 48, 61 }, { 68, 69 } }, // 12: sa[4]'0
     1133                { { 9, 41 } }  // 13: sa[5]'0
     1134            },
     1135            { },
     1136            { },
     1137            { }
     1138        },
     1139        { },
     1140        {   // varRoutineMap
     1141            { 2, { { { 0, 1, 6, 7, 8, 10, 12 }, { }, { }, { } } } }
     1142        },
     1143        {   // varCallMap
     1144            { 0, { { { 13 }, { }, { }, { } } } }
     1145        },
     1146        true, ""
    10881147    }
    10891148};
     
    10991158        throw Exception("getTestSingleVReg: RegVar not found!!");
    11001159    return { it->second, vr.index };
     1160}
     1161
     1162static void checkVVarSetEntries(const std::string& testCaseName, const char* vvarSetName,
     1163        const Array<std::pair<size_t, VVarSetEntry2> >& expVarRoutineMap,
     1164        const std::unordered_map<size_t,VVarSetEntry>& varRoutineMap,
     1165        const std::vector<size_t>* revLvIndexCvtTables)
     1166{
     1167    assertValue("testAsmLivenesses", testCaseName + vvarSetName + ".size",
     1168            varRoutineMap.size(), expVarRoutineMap.size());
     1169   
     1170    for (size_t j = 0; j < varRoutineMap.size(); j++)
     1171    {
     1172        std::ostringstream vOss;
     1173        vOss << vvarSetName << "#" << j;
     1174        vOss.flush();
     1175        std::string vcname(vOss.str());
     1176       
     1177        auto vcit = varRoutineMap.find(expVarRoutineMap[j].first);
     1178        std::ostringstream kOss;
     1179        kOss << expVarRoutineMap[j].first;
     1180        kOss.flush();
     1181        assertTrue("testAsmLivenesses", testCaseName + vcname +".key=" + kOss.str(),
     1182                    vcit != varRoutineMap.end());
     1183       
     1184        const Array<size_t>* expEntry = expVarRoutineMap[j].second.vvars;
     1185        const VVarSetEntry& resEntry = vcit->second;
     1186        for (cxuint r = 0; r < MAX_REGTYPES_NUM; r++)
     1187        {
     1188            std::ostringstream vsOss;
     1189            vsOss << ".vs#" << r;
     1190            vsOss.flush();
     1191            std::string vsname = vcname + vsOss.str();
     1192           
     1193            assertValue("testAsmLivenesses", testCaseName + vsname +".size",
     1194                    expEntry[r].size(), resEntry.vvars[r].size());
     1195           
     1196            std::vector<size_t> resVVars;
     1197            std::transform(resEntry.vvars[r].begin(), resEntry.vvars[r].end(),
     1198                    std::back_inserter(resVVars),
     1199                    [&r,&revLvIndexCvtTables](size_t v)
     1200                    { return revLvIndexCvtTables[r][v]; });
     1201            std::sort(resVVars.begin(), resVVars.end());
     1202            assertArray("testAsmLivenesses", testCaseName + vsname,
     1203                        expEntry[r], resVVars);
     1204        }
     1205    }
    11011206}
    11021207
     
    12641369    }
    12651370   
     1371    // checking varRoutineMap
     1372    checkVVarSetEntries(testCaseName, "varRoutineMap", testCase.varRoutineMap,
     1373                regAlloc.getVarRoutineMap(), revLvIndexCvtTables);
     1374   
    12661375    // checking varCallMap
    1267     const std::unordered_map<size_t, VVarSetEntry>& varCallMap = regAlloc.getVarCallMap();
    1268     assertValue("testAsmLivenesses", testCaseName + "varCallMap.size",
    1269             varCallMap.size(), testCase.varCallMap.size());
    1270    
    1271     for (size_t j = 0; j < varCallMap.size(); j++)
    1272     {
    1273         std::ostringstream vOss;
    1274         vOss << "varCallMap#" << j;
    1275         vOss.flush();
    1276         std::string vcname(vOss.str());
    1277        
    1278         auto vcit = varCallMap.find(testCase.varCallMap[j].first);
    1279         std::ostringstream kOss;
    1280         kOss << testCase.varCallMap[j].first;
    1281         kOss.flush();
    1282         assertTrue("testAsmLivenesses", testCaseName + vcname +".key=" + kOss.str(),
    1283                     vcit != varCallMap.end());
    1284        
    1285         const Array<size_t>* expEntry = testCase.varCallMap[j].second.vvars;
    1286         const VVarSetEntry& resEntry = vcit->second;
    1287         for (cxuint r = 0; r < MAX_REGTYPES_NUM; r++)
    1288         {
    1289             std::ostringstream vsOss;
    1290             vsOss << ".vs#" << r;
    1291             vsOss.flush();
    1292             std::string vsname = vcname + vsOss.str();
    1293            
    1294             assertValue("testAsmLivenesses", testCaseName + vsname +".size",
    1295                     expEntry[r].size(), resEntry.vvars[r].size());
    1296            
    1297             std::vector<size_t> resVVars;
    1298             std::transform(resEntry.vvars[r].begin(), resEntry.vvars[r].end(),
    1299                     std::back_inserter(resVVars),
    1300                     [&r,&revLvIndexCvtTables](size_t v)
    1301                     { return revLvIndexCvtTables[r][v]; });
    1302             std::sort(resVVars.begin(), resVVars.end());
    1303             assertArray("testAsmLivenesses", testCaseName + vsname,
    1304                         expEntry[r], resVVars);
    1305         }
    1306     }
    1307    
    1308     const std::unordered_map<size_t, VVarSetEntry>& varRoutineMap =
    1309                 regAlloc.getVarRoutineMap();
    1310     assertValue("testAsmLivenesses", testCaseName + "varRoutineMap.size",
    1311             varRoutineMap.size(), testCase.varRoutineMap.size());
    1312    
    1313     for (size_t j = 0; j < varRoutineMap.size(); j++)
    1314     {
    1315         std::ostringstream vOss;
    1316         vOss << "varRoutineMap#" << j;
    1317         vOss.flush();
    1318         std::string vcname(vOss.str());
    1319        
    1320         auto vcit = varRoutineMap.find(testCase.varRoutineMap[j].first);
    1321         std::ostringstream kOss;
    1322         kOss << testCase.varRoutineMap[j].first;
    1323         kOss.flush();
    1324         assertTrue("testAsmLivenesses", testCaseName + vcname +".key=" + kOss.str(),
    1325                     vcit != varRoutineMap.end());
    1326        
    1327         const Array<size_t>* expEntry = testCase.varRoutineMap[j].second.vvars;
    1328         const VVarSetEntry& resEntry = vcit->second;
    1329         for (cxuint r = 0; r < MAX_REGTYPES_NUM; r++)
    1330         {
    1331             std::ostringstream vsOss;
    1332             vsOss << ".vs#" << r;
    1333             vsOss.flush();
    1334             std::string vsname = vcname + vsOss.str();
    1335            
    1336             assertValue("testAsmLivenesses", testCaseName + vsname +".size",
    1337                     expEntry[r].size(), resEntry.vvars[r].size());
    1338            
    1339             std::vector<size_t> resVVars;
    1340             std::transform(resEntry.vvars[r].begin(), resEntry.vvars[r].end(),
    1341                     std::back_inserter(resVVars),
    1342                     [&r,&revLvIndexCvtTables](size_t v)
    1343                     { return revLvIndexCvtTables[r][v]; });
    1344             std::sort(resVVars.begin(), resVVars.end());
    1345             assertArray("testAsmLivenesses", testCaseName + vsname,
    1346                         expEntry[r], resVVars);
    1347         }
    1348     }
     1376    checkVVarSetEntries(testCaseName, "varCallMap", testCase.varCallMap,
     1377                regAlloc.getVarCallMap(), revLvIndexCvtTables);
    13491378}
    13501379
Note: See TracChangeset for help on using the changeset viewer.