Changeset 4023 in CLRX


Ignore:
Timestamp:
Apr 18, 2018, 9:09:01 PM (6 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Include random order of the livenesses tables, use index conversion table in AsmRegAlloc3.
Small fix in createLivenesses. Add new getters in AsmRegAllocator? (for testing).

Location:
CLRadeonExtender/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/CLRX/amdasm/Assembler.h

    r4019 r4023  
    397397    const std::unordered_map<size_t, EqualToDep>* getEqualToDepMaps() const
    398398    { return equalToDepMaps; }
     399   
     400    const VarIndexMap* getVregIndexMaps() const
     401    { return vregIndexMaps; }
    399402};
    400403
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.cpp

    r4020 r4023  
    918918            }
    919919        }
    920        
     920   
    921921    /* equalTo dependencies */
    922922    count = edeps[0];
     
    953953{
    954954    // construct var index maps
    955     std::fill(graphVregsCounts, graphVregsCounts+regTypesNum, 0);
    956955    cxuint regRanges[MAX_REGTYPES_NUM*2];
     956    std::fill(graphVregsCounts, graphVregsCounts+MAX_REGTYPES_NUM, size_t(0));
    957957    size_t regTypesNum;
    958958    assembler.isaAssembler->getRegisterRanges(regTypesNum, regRanges);
     
    14451445    for (size_t i = 0; i < MAX_REGTYPES_NUM; i++)
    14461446    {
     1447        graphVregsCounts[i] = 0;
    14471448        vregIndexMaps[i].clear();
    14481449        interGraphs[i].clear();
  • CLRadeonExtender/trunk/tests/amdasm/AsmRegAlloc3.cpp

    r4021 r4023  
    1919
    2020#include <CLRX/Config.h>
     21#include <algorithm>
    2122#include <iostream>
    2223#include <sstream>
     
    3536typedef AsmRegAllocator::LinearDep LinearDep;
    3637typedef AsmRegAllocator::EqualToDep EqualToDep;
     38typedef AsmRegAllocator::VarIndexMap VarIndexMap;
    3739
    3840struct LinearDep2
     
    5860};
    5961
     62static const AsmLivenessesCase createLivenessesCasesTbl[] =
     63{
     64#if 0
     65    {   // 0 - simple case
     66        R"ffDXD(.regvar sa:s:8, va:v:10
     67        s_mov_b32 sa[4], sa[2]  # 0
     68        s_add_u32 sa[4], sa[4], s3
     69        v_xor_b32 va[4], va[2], v3
     70)ffDXD",
     71        {   // livenesses
     72            {   // for SGPRs
     73                { },
     74                { },
     75                { },
     76                { }
     77            },
     78            {   // for VGPRs
     79                { },
     80                { },
     81                { }
     82            },
     83            { },
     84            { }
     85        },
     86        {   // linearDepMaps
     87        },
     88        {   // equalToDepMaps
     89        }, true, ""
     90    }
     91#endif
     92};
     93
     94static TestSingleVReg getTestSingleVReg(const AsmSingleVReg& vr,
     95        const std::unordered_map<const AsmRegVar*, CString>& rvMap)
     96{
     97    if (vr.regVar == nullptr)
     98        return { "", vr.index };
     99   
     100    auto it = rvMap.find(vr.regVar);
     101    if (it == rvMap.end())
     102        throw Exception("getTestSingleVReg: RegVar not found!!");
     103    return { it->second, vr.index };
     104}
     105
    60106static void testCreateLivenessesCase(cxuint i, const AsmLivenessesCase& testCase)
    61107{
     
    92138              testCase.errorMessages, errorStream.str());
    93139   
     140    std::unordered_map<const AsmRegVar*, CString> regVarNamesMap;
     141    for (const auto& rvEntry: assembler.getRegVarMap())
     142        regVarNamesMap.insert(std::make_pair(&rvEntry.second, rvEntry.first));
     143   
     144    // generate livenesses indices conversion table
     145    const VarIndexMap* vregIndexMaps = regAlloc.getVregIndexMaps();
     146   
     147    std::vector<size_t> lvIndexCvtTables[MAX_REGTYPES_NUM];
     148    for (size_t r = 0; r < MAX_REGTYPES_NUM; r++)
     149    {
     150        const VarIndexMap& vregIndexMap = vregIndexMaps[r];
     151        Array<std::pair<TestSingleVReg, const std::vector<size_t>*> > outVregIdxMap(
     152                    vregIndexMap.size());
     153       
     154        size_t i = 0;
     155        for (const auto& entry: vregIndexMap)
     156        {
     157            TestSingleVReg vreg = getTestSingleVReg(entry.first, regVarNamesMap);
     158            outVregIdxMap[i++] = std::make_pair(vreg, &entry.second);
     159        }
     160        mapSort(outVregIdxMap.begin(), outVregIdxMap.end());
     161       
     162        std::vector<size_t>& lvIndexCvtTable = lvIndexCvtTables[r];
     163        // generate livenessCvt table
     164        for (const auto& entry: outVregIdxMap)
     165        {
     166            for (size_t v: *entry.second)
     167                if (v != SIZE_MAX)
     168                    lvIndexCvtTable.push_back(v);
     169        }
     170    }
     171   
    94172    const Array<OutLiveness>* resLivenesses = regAlloc.getOutLivenesses();
    95173    for (size_t r = 0; r < MAX_REGTYPES_NUM; r++)
    96174    {
    97175        std::ostringstream rOss;
    98         rOss << "live.regtype#" << r << ".";
     176        rOss << "live.regtype#" << r;
    99177        rOss.flush();
    100178        std::string rtname(rOss.str());
     
    110188            std::string lvname(rtname + lOss.str());
    111189            const OutLiveness& expLv = testCase.livenesses[r][li];
    112             const OutLiveness& resLv = resLivenesses[r][li];
     190            const OutLiveness& resLv = resLivenesses[r][lvIndexCvtTables[r][li]];
    113191           
    114192            // checking liveness
     
    134212    {
    135213        std::ostringstream rOss;
    136         rOss << "lndep.regtype#" << r << ".";
     214        rOss << "lndep.regtype#" << r;
    137215        rOss.flush();
    138216        std::string rtname(rOss.str());
     
    160238            assertValue("testAsmLivenesses", testCaseName + ldname + ".align",
    161239                        cxuint(expLinearDep.align), cxuint(resLinearDep.align));
     240           
     241            Array<size_t> expPrevVidxes(expLinearDep.prevVidxes.size());
     242            // convert to res ssaIdIndices
     243            for (size_t k = 0; k < expLinearDep.prevVidxes.size(); k++)
     244                expPrevVidxes[k] = lvIndexCvtTables[r][expLinearDep.prevVidxes[k]];
     245           
    162246            assertArray("testAsmLivenesses", testCaseName + ldname + ".prevVidxes",
    163                         expLinearDep.prevVidxes, resLinearDep.prevVidxes);
     247                        expPrevVidxes, resLinearDep.prevVidxes);
     248           
     249            Array<size_t> expNextVidxes(expLinearDep.nextVidxes.size());
     250            // convert to res ssaIdIndices
     251            for (size_t k = 0; k < expLinearDep.nextVidxes.size(); k++)
     252                expNextVidxes[k] = lvIndexCvtTables[r][expLinearDep.nextVidxes[k]];
     253           
    164254            assertArray("testAsmLivenesses", testCaseName + ldname + ".nextVidxes",
    165                         expLinearDep.nextVidxes, resLinearDep.nextVidxes);
     255                        expNextVidxes, resLinearDep.nextVidxes);
    166256        }
    167257    }
     
    172262    {
    173263        std::ostringstream rOss;
    174         rOss << "eqtodep.regtype#" << r << ".";
     264        rOss << "eqtodep.regtype#" << r;
    175265        rOss.flush();
    176266        std::string rtname(rOss.str());
     
    196286            const EqualToDep& resEqualToDep = reit->second;
    197287           
     288            Array<size_t> expPrevVidxes(expEqualToDep.prevVidxes.size());
     289            // convert to res ssaIdIndices
     290            for (size_t k = 0; k < expEqualToDep.prevVidxes.size(); k++)
     291                expPrevVidxes[k] = lvIndexCvtTables[r][expEqualToDep.prevVidxes[k]];
     292           
    198293            assertArray("testAsmLivenesses", testCaseName + ldname + ".prevVidxes",
    199                         expEqualToDep.prevVidxes, resEqualToDep.prevVidxes);
     294                        expPrevVidxes, resEqualToDep.prevVidxes);
     295           
     296            Array<size_t> expNextVidxes(expEqualToDep.nextVidxes.size());
     297            // convert to res ssaIdIndices
     298            for (size_t k = 0; k < expEqualToDep.nextVidxes.size(); k++)
     299                expNextVidxes[k] = lvIndexCvtTables[r][expEqualToDep.nextVidxes[k]];
     300           
    200301            assertArray("testAsmLivenesses", testCaseName + ldname + ".nextVidxes",
    201                         expEqualToDep.nextVidxes, resEqualToDep.nextVidxes);
     302                        expNextVidxes, resEqualToDep.nextVidxes);
    202303        }
    203304    }
     
    207308{
    208309    int retVal = 0;
     310    for (size_t i = 0; i < sizeof(createLivenessesCasesTbl)/sizeof(AsmLivenessesCase); i++)
     311        try
     312        { testCreateLivenessesCase(i, createLivenessesCasesTbl[i]); }
     313        catch(const std::exception& ex)
     314        {
     315            std::cerr << ex.what() << std::endl;
     316            retVal = 1;
     317        }
    209318    return retVal;
    210319}
Note: See TracChangeset for help on using the changeset viewer.