Changeset 4104 in CLRX


Ignore:
Timestamp:
May 7, 2018, 7:29:50 PM (5 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: add joinRoutineDataLv (join routines while createRoutineDataLv), add last accesses of svregs to lastAccessMap,
add reverting that changes while returning from code block (createLivenesses).

Location:
CLRadeonExtender/trunk/amdasm
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.cpp

    r4101 r4104  
    13461346}
    13471347
     1348static void joinRoutineDataLv(RoutineDataLv& dest, RoutineCurAccessMap& curSVRegMap,
     1349            FlowStackEntry4& entry, const RoutineDataLv& src)
     1350{
     1351    dest.rbwSSAIdMap.insert(src.rbwSSAIdMap.begin(), src.rbwSSAIdMap.end());
     1352    for (size_t i = 0; i < MAX_REGTYPES_NUM; i++)
     1353        dest.allSSAs[i].insert(src.allSSAs[i].begin(), src.allSSAs[i].end());
     1354   
     1355    // join source lastAccessMap with curSVRegMap
     1356    for (const auto& sentry: src.lastAccessMap)
     1357    {
     1358        auto res = curSVRegMap.insert({ sentry.first, { entry.blockIndex, true } });
     1359        if (!res.second)
     1360        {   // not added because is present in map
     1361            if (res.first->second.blockIndex != entry.blockIndex)
     1362                entry.prevCurSVRegMap.insert(*res.first);
     1363            // otherwise, it is same code block but inside routines
     1364            // and do not change prevCurSVRegMap for revert
     1365            // update entry
     1366            res.first->second = { entry.blockIndex, true };
     1367        }
     1368        else
     1369            entry.prevCurSVRegMap.insert({ sentry.first, { SIZE_MAX, true } });
     1370    }
     1371}
    13481372
    13491373static void createRoutineDataLv(const std::vector<CodeBlock>& codeBlocks,
     
    13601384   
    13611385    flowStack.push_back({ routineBlock, 0 });
    1362     SVRegMap curSVRegMap; // key - svreg, value - block index
     1386    RoutineCurAccessMap curSVRegMap; // key - svreg, value - block index
    13631387   
    13641388    while (!flowStack.empty())
     
    13821406                                        sentry.second.ssaIdBefore });
    13831407                   
    1384                     auto res = curSVRegMap.insert({ sentry.first, entry.blockIndex });
     1408                    auto res = curSVRegMap.insert({ sentry.first,
     1409                        LastAccessBlockPos{ entry.blockIndex, false } });
    13851410                    if (!res.second)
    13861411                    {   // not added because is present in map
    13871412                        entry.prevCurSVRegMap.insert(*res.first);
    1388                         res.first->second = entry.blockIndex;
     1413                        res.first->second = { entry.blockIndex, false };
    13891414                    }
    13901415                    else
    1391                         entry.prevCurSVRegMap.insert({ sentry.first, SIZE_MAX });
     1416                        entry.prevCurSVRegMap.insert(
     1417                                        { sentry.first, { SIZE_MAX, false } });
    13921418                   
    13931419                    // all SSAs
     
    14181444        }
    14191445       
     1446        // join and skip calls
     1447        {
     1448            std::vector<size_t> calledRoutines;
     1449            for (; entry.nextIndex < cblock.nexts.size() &&
     1450                        cblock.nexts[entry.nextIndex].isCall; entry.nextIndex++)
     1451            {
     1452                size_t rblock = cblock.nexts[entry.nextIndex].block;
     1453                if (rblock != routineBlock)
     1454                    calledRoutines.push_back(rblock);
     1455            }
     1456           
     1457            for (size_t srcRoutBlock: calledRoutines)
     1458                joinRoutineDataLv(rdata, curSVRegMap, entry,
     1459                        routineMap.find(srcRoutBlock)->second);
     1460        }
     1461       
    14201462        if (entry.nextIndex < cblock.nexts.size())
    14211463        {
     
    14361478            {
    14371479                // handle return
     1480                // add curSVReg access positions to lastAccessMap
    14381481                for (const auto& entry: curSVRegMap)
    14391482                {
    14401483                    auto res = rdata.lastAccessMap.insert({ entry.first,
    1441                                     { LastAccessBlockPos{  entry.second, false } } });
     1484                                    { entry.second } });
    14421485                    if (!res.second)
    1443                         res.first->second.insertValue(
    1444                                     LastAccessBlockPos{ entry.second, false });
     1486                        res.first->second.insertValue(entry.second);
    14451487                }
    14461488            }
    14471489            // revert curSVRegMap
    14481490            for (const auto& sentry: entry.prevCurSVRegMap)
    1449                 if (sentry.second != SIZE_MAX)
     1491                if (sentry.second.blockIndex != SIZE_MAX)
    14501492                    curSVRegMap.find(sentry.first)->second = sentry.second;
    14511493                else // no before that
     
    14631505            flowStack.pop_back();
    14641506        }
     1507    }
     1508}
     1509
     1510static inline void revertLastSVReg(LastVRegMap& lastVRegMap, const AsmSingleVReg& svreg)
     1511{
     1512    auto lvrit = lastVRegMap.find(svreg);
     1513    if (lvrit != lastVRegMap.end())
     1514    {
     1515        std::vector<LastVRegStackPos>& lastPos = lvrit->second;
     1516        lastPos.pop_back();
     1517        if (lastPos.empty()) // just remove from lastVRegs
     1518            lastVRegMap.erase(lvrit);
    14651519    }
    14661520}
     
    17331787            entry.nextIndex++;
    17341788        }
    1735         else if (entry.nextIndex==0 && cblock.nexts.empty() && !cblock.haveEnd)
    1736         {
     1789        else if (((entry.nextIndex==0 && cblock.nexts.empty()) ||
     1790                // if have any call then go to next block
     1791                (cblock.haveCalls && entry.nextIndex==cblock.nexts.size())) &&
     1792                 !cblock.haveReturn && !cblock.haveEnd)
     1793        {
     1794            if (entry.nextIndex!=0) // if back from calls (just return from calls)
     1795            {
     1796                std::unordered_set<AsmSingleVReg> regSVRegs;
     1797                // just add last access of svreg from call routines to lastVRegMap
     1798                for (const NextBlock& next: cblock.nexts)
     1799                    if (next.isCall)
     1800                    {
     1801                        const RoutineDataLv& rdata = routineMap.find(next.block)->second;
     1802                        for (const auto& entry: rdata.lastAccessMap)
     1803                            if (regSVRegs.insert(entry.first).second)
     1804                            {
     1805                                auto res = lastVRegMap.insert({ entry.first,
     1806                                        { { flowStack.size()-1, true } } });
     1807                                if (!res.second) // if not first seen, just update
     1808                                    // update last
     1809                                    res.first->second.push_back(
     1810                                                { flowStack.size()-1, true });
     1811                            }
     1812                    }
     1813            }
     1814           
    17371815            flowStack.push_back({ entry.blockIndex+1, 0 });
    17381816            entry.nextIndex++;
     
    17421820            // revert lastSSAIdMap
    17431821            flowStack.pop_back();
    1744             if (!flowStack.empty())
    1745                 for (const auto& sentry: cblock.ssaInfoMap)
    1746                 {
    1747                     auto lvrit = lastVRegMap.find(sentry.first);
    1748                     if (lvrit != lastVRegMap.end())
    1749                     {
    1750                         std::vector<LastVRegStackPos>& lastPos = lvrit->second;
    1751                         lastPos.pop_back();
    1752                         if (lastPos.empty()) // just remove from lastVRegs
    1753                             lastVRegMap.erase(lvrit);
    1754                     }
     1822           
     1823            // revert lastVRegs in call
     1824            std::unordered_set<AsmSingleVReg> revertedSVRegs;
     1825            for (const NextBlock& next: cblock.nexts)
     1826                if (next.isCall)
     1827                {
     1828                    const RoutineDataLv& rdata = routineMap.find(next.block)->second;
     1829                    for (const auto& entry: rdata.lastAccessMap)
     1830                        if (revertedSVRegs.insert(entry.first).second)
     1831                            revertLastSVReg(lastVRegMap, entry.first);
    17551832                }
     1833           
     1834            for (const auto& sentry: cblock.ssaInfoMap)
     1835                revertLastSVReg(lastVRegMap, sentry.first);
    17561836           
    17571837            if (!flowStack.empty() && lastCommonCacheWayPoint.first != SIZE_MAX &&
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.h

    r4099 r4104  
    211211
    212212typedef std::unordered_map<AsmSingleVReg, VectorSet<LastAccessBlockPos> > LastAccessMap;
     213typedef std::unordered_map<AsmSingleVReg, LastAccessBlockPos> RoutineCurAccessMap;
    213214
    214215// Routine data for createLivenesses - holds svreg read before writes and
     
    255256    size_t nextIndex;
    256257    bool isCall;
    257     SVRegMap prevCurSVRegMap;
     258    RoutineCurAccessMap prevCurSVRegMap;
    258259};
    259260
Note: See TracChangeset for help on using the changeset viewer.