Changeset 4118 in CLRX


Ignore:
Timestamp:
May 8, 2018, 8:32:44 PM (3 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Extend a testing routine by checking varCallMap and varRoutineMap.

File:
1 edited

Legend:

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

    r4117 r4118  
    3636typedef AsmRegAllocator::LinearDep LinearDep;
    3737typedef AsmRegAllocator::VarIndexMap VarIndexMap;
     38typedef AsmRegAllocator::VVarSetEntry VVarSetEntry;
    3839
    3940struct LinearDep2
     
    4445};
    4546
     47typedef Array<size_t> VVarSetEntry2[4];
     48
    4649struct AsmLivenessesCase
    4750{
     
    4952    Array<OutLiveness> livenesses[MAX_REGTYPES_NUM];
    5053    Array<std::pair<size_t, LinearDep2> > linearDepMaps[MAX_REGTYPES_NUM];
     54    Array<std::pair<size_t, VVarSetEntry2> > varRoutineMap;
     55    Array<std::pair<size_t, VVarSetEntry2> > varCallMap;
    5156    bool good;
    5257    const char* errorMessages;
     
    7782        },
    7883        { },  // linearDepMaps
     84        { },  // varRoutineMap
     85        { },  // varCallMap
    7986        true, ""
    8087    },
     
    102109        },
    103110        { },  // linearDepMaps
     111        { },  // varRoutineMap
     112        { },  // varCallMap
    104113        true, ""
    105114    },
     
    172181            { }
    173182        },
     183        { },  // varRoutineMap
     184        { },  // varCallMap
    174185        true, ""
    175186    },
     
    210221        },
    211222        { }, // linearDepMaps
     223        { },  // varRoutineMap
     224        { },  // varCallMap
    212225        true, ""
    213226    },
     
    259272        },
    260273        { }, // linearDepMaps
     274        { },  // varRoutineMap
     275        { },  // varCallMap
    261276        true, ""
    262277    },
     
    313328            { }
    314329        },
     330        { },  // varRoutineMap
     331        { },  // varCallMap
    315332        true, ""
    316333    },
     
    391408            { }
    392409        },
     410        { },  // varRoutineMap
     411        { },  // varCallMap
    393412        true, ""
    394413    },
     
    497516            { }
    498517        },
    499         {   // linearDepMaps
    500             { },
    501             { },
    502             { },
    503             { }
    504         },
     518        { },  // linearDepMaps
     519        { },  // varRoutineMap
     520        { },  // varCallMap
    505521        true, ""
    506522    },
     
    575591            { }
    576592        },
    577         {   // linearDepMaps
    578             { },
    579             { },
    580             { },
    581             { }
    582         },
     593        { },  // linearDepMaps
     594        { },  // varRoutineMap
     595        { },  // varCallMap
    583596        true, ""
    584597    },
     
    622635            { }
    623636        },
    624         {   // linearDepMaps
    625             { },
    626             { },
    627             { },
    628             { }
    629         },
     637        { },  // linearDepMaps
     638        { },  // varRoutineMap
     639        { },  // varCallMap
    630640        true, ""
    631641    },
     
    683693            { }
    684694        },
    685         {   // linearDepMaps
    686             { },
    687             { },
    688             { },
    689             { }
    690         },
     695        { },  // linearDepMaps
     696        { },  // varRoutineMap
     697        { },  // varCallMap
    691698        true, ""
    692699    },
     
    742749            { }
    743750        },
    744         {   // linearDepMaps
    745             { },
    746             { },
    747             { },
    748             { }
    749         },
     751        { },  // linearDepMaps
     752        { },  // varRoutineMap
     753        { },  // varCallMap
    750754        true, ""
    751755    },
     
    773777            { }
    774778        },
    775         {   // linearDepMaps
    776             { },
    777             { },
    778             { },
    779             { }
    780         },
     779        { },  // linearDepMaps
     780        { },  // varRoutineMap
     781        { },  // varCallMap
    781782        true, ""
    782783    },
     
    805806            { }
    806807        },
    807         {   // linearDepMaps
    808             { },
    809             { },
    810             { },
    811             { }
    812         },
     808        { },  // linearDepMaps
     809        { },  // varRoutineMap
     810        { },  // varCallMap
    813811        true, ""
    814812    },
     
    902900            { }
    903901        },
     902        { },  // varRoutineMap
     903        { },  // varCallMap
    904904        true, ""
    905905    },
     
    933933            { }
    934934        },
    935         {   // linearDepMaps
    936             { },
    937             { },
    938             { },
    939             { }
    940         },
     935        { },  // linearDepMaps
     936        { },  // varRoutineMap
     937        { },  // varCallMap
    941938        true, ""
    942939    },
     
    968965            { }
    969966        },
    970         {   // linearDepMaps
    971             { },
    972             { },
    973             { },
    974             { }
    975         },
     967        { },  // linearDepMaps
     968        { },  // varRoutineMap
     969        { },  // varCallMap
    976970        true, ""
    977971    },
     
    1001995            {   // for SGPRs
    1002996                { { 29, 32 }, { 44, 53 } }, // 0: S0
    1003                 { }, // 1: S1
    1004                 { }, // 2: S2
    1005                 { }, // 3: S3
    1006                 { }, // 4: S4
    1007                 { }, // 5: S5
    1008                 { }, // 6: sa[2]'0
     997                { { 29, 32 }, { 44, 53 } }, // 1: S1
     998                { { 9, 29 } }, // 2: S2
     999                { { 9, 29 } }, // 3: S3
     1000                { { 0, 1 } }, // 4: S4
     1001                { { 0, 5 } }, // 5: S5
     1002                { { 1, 32 }, { 44, 45 } }, // 6: sa[2]'0
    10091003                { }, // 7: sa[2]'1
    10101004                { }, // 8: sa[2]'2
     
    10181012            { }
    10191013        },
    1020         {
    1021             { },
    1022             { },
    1023             { },
    1024             { }
    1025         },
     1014        { }, //
     1015        { },  // varRoutineMap
     1016        { },  // varCallMap
    10261017        true, ""
    10271018    }
     
    11521143    }
    11531144   
     1145    // checking linearDepMaps
    11541146    const std::unordered_map<size_t, LinearDep>* resLinearDepMaps =
    11551147                regAlloc.getLinearDepMaps();
     
    12021194        }
    12031195    }
     1196   
     1197    // checking varCallMap
     1198    const std::unordered_map<size_t, VVarSetEntry>& varCallMap = regAlloc.getVarCallMap();
     1199    assertValue("testAsmLivenesses", testCaseName + "varCallMap.size",
     1200            varCallMap.size(), testCase.varCallMap.size());
     1201   
     1202    for (size_t j = 0; j < varCallMap.size(); j++)
     1203    {
     1204        std::ostringstream vOss;
     1205        vOss << "varCallMap#" << j;
     1206        vOss.flush();
     1207        std::string vcname(vOss.str());
     1208       
     1209        auto vcit = varCallMap.find(testCase.varCallMap[j].first);
     1210        std::ostringstream kOss;
     1211        kOss << testCase.varCallMap[j].first;
     1212        kOss.flush();
     1213        assertTrue("testAsmLivenesses", testCaseName + vcname +".key=" + kOss.str(),
     1214                    vcit != varCallMap.end());
     1215       
     1216        const VVarSetEntry2& expEntry = testCase.varCallMap[j].second;
     1217        const VVarSetEntry& resEntry = vcit->second;
     1218        for (cxuint r = 0; r < MAX_REGTYPES_NUM; r++)
     1219        {
     1220            std::ostringstream vsOss;
     1221            vsOss << ".vs#" << r;
     1222            vsOss.flush();
     1223            std::string vsname = vcname + vsOss.str();
     1224           
     1225            assertValue("testAsmLivenesses", testCaseName + vsname +".size",
     1226                    expEntry[r].size(), resEntry.vvars[r].size());
     1227           
     1228            for (size_t k = 0; k < expEntry[r].size(); k++)
     1229            {
     1230                std::ostringstream vskOss;
     1231                vskOss << ".elem#" << r << "=" << expEntry[r][k];
     1232                vskOss.flush();
     1233                std::string vskname = vsname + vskOss.str();
     1234               
     1235                assertTrue("testAsmLivenesses", testCaseName + vskname +".size",
     1236                        resEntry.vvars[r].find(lvIndexCvtTables[r][expEntry[r][k]]) !=
     1237                        resEntry.vvars[r].end());
     1238            }
     1239        }
     1240    }
     1241   
     1242    const std::unordered_map<size_t, VVarSetEntry>& varRoutineMap =
     1243                regAlloc.getVarRoutineMap();
     1244    assertValue("testAsmLivenesses", testCaseName + "varRoutineMap.size",
     1245            varRoutineMap.size(), testCase.varRoutineMap.size());
     1246   
     1247    for (size_t j = 0; j < varRoutineMap.size(); j++)
     1248    {
     1249        std::ostringstream vOss;
     1250        vOss << "varRoutineMap#" << j;
     1251        vOss.flush();
     1252        std::string vcname(vOss.str());
     1253       
     1254        auto vcit = varRoutineMap.find(testCase.varRoutineMap[j].first);
     1255        std::ostringstream kOss;
     1256        kOss << testCase.varRoutineMap[j].first;
     1257        kOss.flush();
     1258        assertTrue("testAsmLivenesses", testCaseName + vcname +".key=" + kOss.str(),
     1259                    vcit != varRoutineMap.end());
     1260       
     1261        const VVarSetEntry2& expEntry = testCase.varRoutineMap[j].second;
     1262        const VVarSetEntry& resEntry = vcit->second;
     1263        for (cxuint r = 0; r < MAX_REGTYPES_NUM; r++)
     1264        {
     1265            std::ostringstream vsOss;
     1266            vsOss << ".vs#" << r;
     1267            vsOss.flush();
     1268            std::string vsname = vcname + vsOss.str();
     1269           
     1270            assertValue("testAsmLivenesses", testCaseName + vsname +".size",
     1271                    expEntry[r].size(), resEntry.vvars[r].size());
     1272           
     1273            for (size_t k = 0; k < expEntry[r].size(); k++)
     1274            {
     1275                std::ostringstream vskOss;
     1276                vskOss << ".elem#" << r << "=" << expEntry[r][k];
     1277                vskOss.flush();
     1278                std::string vskname = vsname + vskOss.str();
     1279               
     1280                assertTrue("testAsmLivenesses", testCaseName + vskname +".size",
     1281                        resEntry.vvars[r].find(lvIndexCvtTables[r][expEntry[r][k]]) !=
     1282                        resEntry.vvars[r].end());
     1283            }
     1284        }
     1285    }
    12041286}
    12051287
Note: See TracChangeset for help on using the changeset viewer.