Changeset 4099 in CLRX


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

CLRadeonExtender: AsmRegAlloc?: Fixed stupid bug in Liveness:contain (segfault on empty l). Integrate joinVRegRecur with the rest of code.

Location:
CLRadeonExtender/trunk/amdasm
Files:
2 edited

Legend:

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

    r4098 r4099  
    735735}
    736736
    737 /* TODO: add handling calls
    738  * handle many start points in this code (for example many kernel's in same code)
    739  * replace sets by vector, and sort and remove same values on demand
    740  */
    741 
    742 /* join livenesses between consecutive code blocks */
    743 static void putCrossBlockLivenesses(const std::deque<FlowStackEntry3>& flowStack,
    744         const std::vector<CodeBlock>& codeBlocks, const LastVRegMap& lastVRegMap,
    745         std::vector<Liveness>* livenesses, const VarIndexMap* vregIndexMaps,
    746         size_t regTypesNum, const cxuint* regRanges)
    747 {
    748     ARDOut << "putCrossBlockLv block: " << flowStack.back().blockIndex << "\n";
    749     const CodeBlock& cblock = codeBlocks[flowStack.back().blockIndex];
    750     for (const auto& entry: cblock.ssaInfoMap)
    751         if (entry.second.readBeforeWrite)
    752         {
    753             // find last
    754             auto lvrit = lastVRegMap.find(entry.first);
    755             FlowStackCIter flit = flowStack.begin();
    756             if (lvrit != lastVRegMap.end())
    757                 flit += lvrit->second.back().stackPos;
    758            
    759             cxuint regType = getRegType(regTypesNum, regRanges, entry.first);
    760             const VarIndexMap& vregIndexMap = vregIndexMaps[regType];
    761             const std::vector<size_t>& ssaIdIndices =
    762                         vregIndexMap.find(entry.first)->second;
    763             Liveness& lv = livenesses[regType][ssaIdIndices[entry.second.ssaIdBefore]];
    764             FlowStackCIter flitEnd = flowStack.end();
    765             --flitEnd; // before last element
    766            
    767             ARDOut << "  putCross for " << entry.first.regVar << ":" <<
    768                     entry.first.index << "\n";
    769             // insert live time to last seen position
    770             const CodeBlock& lastBlk = codeBlocks[flit->blockIndex];
    771            
    772             auto sinfoIt = lastBlk.ssaInfoMap.find(entry.first);
    773             size_t lastPos = lastBlk.start;
    774             if (sinfoIt != lastBlk.ssaInfoMap.end())
    775             {
    776                 // if begin at some point at last block
    777                 lastPos = sinfoIt->second.lastPos;
    778                 lv.insert(lastPos + 1, lastBlk.end);
    779                 ++flit; // skip last block in stack
    780             }
    781            
    782             for (; flit != flitEnd; ++flit)
    783             {
    784                 const CodeBlock& cblock = codeBlocks[flit->blockIndex];
    785                 lv.insert(cblock.start, cblock.end);
    786             }
    787         }
    788 }
    789 
    790737static void fillUpInsideRoutine(std::vector<bool>& visited,
    791738            const std::vector<CodeBlock>& codeBlocks, size_t startBlock,
     
    844791    }
    845792}
    846            
    847793
    848794static void joinVRegRecur(const std::deque<FlowStackEntry3>& flowStack,
    849795            const std::vector<CodeBlock>& codeBlocks, const RoutineLvMap& routineMap,
    850             size_t flowStackStart, const AsmSingleVReg& svreg,
    851             const LastAccessBlockPos& lastAccessPos,
     796            LastVRegStackPos flowStkStart, const AsmSingleVReg& svreg, size_t ssaId,
    852797            const VarIndexMap* vregIndexMaps, std::vector<Liveness>* livenesses,
    853             size_t regTypesNum, const cxuint* regRanges)
     798            size_t regTypesNum, const cxuint* regRanges, bool skipLastBlock = false)
    854799{
    855800    struct JoinEntry
     
    860805        bool inSubroutines;
    861806    };
    862     Liveness* lv = nullptr;
     807   
     808    FlowStackCIter flitEnd = flowStack.end();
     809    if (skipLastBlock)
     810        --flitEnd; // before last element
     811    Liveness& lv = getLiveness2(svreg, ssaId, livenesses, vregIndexMaps,
     812                    regTypesNum, regRanges);
     813   
     814    if (flitEnd != flowStack.begin())
     815    {
     816        const CodeBlock& cbLast = codeBlocks[(flitEnd-1)->blockIndex];
     817        if (lv.contain(cbLast.end-1))
     818            // if already filled up
     819            return;
     820    }
     821   
    863822    std::vector<bool> visited(codeBlocks.size(), false);
    864823   
    865824    std::stack<JoinEntry> rjStack; // routine join stack
    866     if (lastAccessPos.inSubroutines)
    867         rjStack.push({ lastAccessPos.blockIndex, 0, 0, true });
     825    if (flowStkStart.inSubroutines)
     826        rjStack.push({ flowStack[flowStkStart.stackPos].blockIndex, 0, 0, true });
    868827   
    869828    while (!rjStack.empty())
     
    909868        {
    910869            size_t blockStart = entry.blockIndex;
    911             if (lv == nullptr)
    912             {
    913                 const SSAInfo& ssaInfo = codeBlocks[blockStart]
    914                             .ssaInfoMap.find(svreg)->second;
    915                 lv = &getLiveness2(svreg, (ssaInfo.ssaIdChange==0) ?
    916                         ssaInfo.ssaIdBefore : ssaInfo.ssaIdLast,
    917                         livenesses, vregIndexMaps, regTypesNum, regRanges);
    918             }
    919870            if (!entry.inSubroutines)
    920                 fillUpInsideRoutine(visited, codeBlocks, blockStart, svreg, *lv);
     871                fillUpInsideRoutine(visited, codeBlocks, blockStart, svreg, lv);
    921872            else
    922873            {
     
    926877                    if (!cbstart.nexts[k].isCall)
    927878                        fillUpInsideRoutine(visited, codeBlocks,
    928                                 cbstart.nexts[k].block, svreg, *lv);
     879                                cbstart.nexts[k].block, svreg, lv);
    929880            }
    930881            rjStack.pop();
     
    932883    }
    933884   
    934     auto flit = flowStack.begin() + flowStackStart;
    935     if (lv == nullptr)
    936     {
    937         size_t blockStart = flit->blockIndex;
    938         auto ssaInfoIt = codeBlocks[blockStart].ssaInfoMap.find(svreg);
    939         size_t ssaId = 0;
    940         if (ssaInfoIt != codeBlocks[blockStart].ssaInfoMap.end())
    941             ssaId = (ssaInfoIt->second.ssaIdChange==0) ? ssaInfoIt->second.ssaIdLast :
    942                     ssaInfoIt->second.ssaIdBefore;
    943         lv = &getLiveness2(svreg, ssaId, livenesses, vregIndexMaps,
    944                         regTypesNum, regRanges);
    945     }
    946    
     885    auto flit = flowStack.begin() + flowStkStart.stackPos + (flowStkStart.inSubroutines);
     886    const CodeBlock& lastBlk = codeBlocks[flit->blockIndex];
     887   
     888    auto sinfoIt = lastBlk.ssaInfoMap.find(svreg);
     889    size_t lastPos = lastBlk.start;
     890    if (sinfoIt != lastBlk.ssaInfoMap.end())
     891    {
     892        // if begin at some point at last block
     893        lastPos = sinfoIt->second.lastPos;
     894        lv.insert(lastPos + 1, lastBlk.end);
     895        ++flit; // skip last block in stack
     896    }
    947897    // fill up to this
    948     for (; flit != flowStack.end(); ++flit)
     898    for (; flit != flitEnd; ++flit)
    949899    {
    950900        const CodeBlock& cblock = codeBlocks[flit->blockIndex];
    951         lv->insert(cblock.start, cblock.end);
    952     }
    953 }
    954            
    955 
    956 static void joinSVregWithVisited(const SVRegMap* stackVarMap, const AsmSingleVReg& vreg,
     901        lv.insert(cblock.start, cblock.end);
     902    }
     903}
     904
     905/* TODO: add handling calls
     906 * handle many start points in this code (for example many kernel's in same code)
     907 * replace sets by vector, and sort and remove same values on demand
     908 */
     909
     910/* join livenesses between consecutive code blocks */
     911static void putCrossBlockLivenesses(const std::deque<FlowStackEntry3>& flowStack,
     912        const std::vector<CodeBlock>& codeBlocks, const RoutineLvMap& routineMap,
     913        const LastVRegMap& lastVRegMap, std::vector<Liveness>* livenesses,
     914        const VarIndexMap* vregIndexMaps, size_t regTypesNum, const cxuint* regRanges)
     915{
     916    ARDOut << "putCrossBlockLv block: " << flowStack.back().blockIndex << "\n";
     917    const CodeBlock& cblock = codeBlocks[flowStack.back().blockIndex];
     918    for (const auto& entry: cblock.ssaInfoMap)
     919        if (entry.second.readBeforeWrite)
     920        {
     921            // find last
     922            auto lvrit = lastVRegMap.find(entry.first);
     923            LastVRegStackPos flowStackStart = (lvrit != lastVRegMap.end()) ?
     924                lvrit->second.back() : LastVRegStackPos{ 0, false };
     925           
     926            joinVRegRecur(flowStack, codeBlocks, routineMap, flowStackStart,
     927                    entry.first, entry.second.ssaIdBefore, vregIndexMaps, livenesses,
     928                    regTypesNum, regRanges, true);
     929        }
     930}
     931
     932static void joinSVregWithVisited(const SVRegMap* stackVarMap,
     933            const RoutineLvMap& routineMap, const AsmSingleVReg& svreg,
    957934            size_t ssaIdNextBefore, const std::deque<FlowStackEntry3>& prevFlowStack,
    958935            const std::vector<CodeBlock>& codeBlocks, const VarIndexMap* vregIndexMaps,
     
    962939    --pfEnd;
    963940   
    964     Liveness& lv = getLiveness2(vreg, ssaIdNextBefore,
     941    Liveness& lv = getLiveness2(svreg, ssaIdNextBefore,
    965942            livenesses, vregIndexMaps, regTypesNum, regRanges);
    966943   
     
    973950    // only if in previous block previous SSAID is
    974951    // read before all writes
    975     auto it = stackVarMap->find(vreg);
    976    
     952    auto it = stackVarMap->find(svreg);
    977953    const size_t pfStart = (it != stackVarMap->end() ? it->second : 0);
    978     //if (it == stackVarMap.end())
    979         //continue;
    980     // fill up previous part
    981     auto flit = prevFlowStack.begin() + pfStart;
    982     {
    983         // fill up liveness for first code block
    984         const CodeBlock& cblock = codeBlocks[flit->blockIndex];
    985         auto ssaInfoIt = cblock.ssaInfoMap.find(vreg);
    986         size_t prevLastPos = (ssaInfoIt != cblock.ssaInfoMap.end()) ?
    987                 ssaInfoIt->second.lastPos+1 : cblock.start;
    988         lv.insert(prevLastPos, cblock.end);
    989     }
    990    
    991     for (++flit; flit != pfEnd; ++flit)
    992     {
    993         const CodeBlock& cblock = codeBlocks[flit->blockIndex];
    994         lv.insert(cblock.start, cblock.end);
    995     }
     954   
     955    joinVRegRecur(prevFlowStack, codeBlocks, routineMap,
     956            LastVRegStackPos{ pfStart, false }, svreg, ssaIdNextBefore, vregIndexMaps,
     957            livenesses, regTypesNum, regRanges, true);
    996958}
    997959
     
    11261088
    11271089static void joinRegVarLivenesses(const std::deque<FlowStackEntry3>& prevFlowStack,
    1128         const std::vector<CodeBlock>& codeBlocks,
     1090        const std::vector<CodeBlock>& codeBlocks, const RoutineLvMap& routineMap,
    11291091        const PrevWaysIndexMap& prevWaysIndexMap,
    11301092        const std::vector<bool>& waysToCache, ResSecondPointsToCache& cblocksToCache,
     
    12221184                       
    12231185                        if (res.second && sinfo.readBeforeWrite)
    1224                             joinSVregWithVisited(&stackVarMap, sentry.first,
     1186                            joinSVregWithVisited(&stackVarMap, routineMap, sentry.first,
    12251187                                sentry.second.ssaIdBefore, prevFlowStack, codeBlocks,
    12261188                                vregIndexMaps, livenesses, regTypesNum, regRanges);
     
    12401202                                cacheSecPoints[rsentry.first] = rsentry.second;
    12411203                           
    1242                             joinSVregWithVisited(&stackVarMap, rsentry.first,
     1204                            joinSVregWithVisited(&stackVarMap, routineMap, rsentry.first,
    12431205                                    rsentry.second, prevFlowStack, codeBlocks,
    12441206                                    vregIndexMaps, livenesses, regTypesNum, regRanges);
     
    16231585                ARDOut << "joinpush: " << entry.blockIndex << "\n";
    16241586                if (flowStack.size() > 1)
    1625                     putCrossBlockLivenesses(flowStack, codeBlocks, lastVRegMap,
     1587                    putCrossBlockLivenesses(flowStack, codeBlocks, routineMap, lastVRegMap,
    16261588                            livenesses, vregIndexMaps, regTypesNum, regRanges);
    16271589                // update last vreg position
     
    17631725                    // find last
    17641726                    auto lvrit = lastVRegMap.find(entry.first);
    1765                     FlowStackCIter flit = flowStack.begin();
    1766                     if (lvrit != lastVRegMap.end())
    1767                         flit += lvrit->second.back().stackPos;
     1727                    LastVRegStackPos flowStackStart = (lvrit != lastVRegMap.end()) ?
     1728                            lvrit->second.back() : LastVRegStackPos{ 0, false };
    17681729                   
    1769                     const CodeBlock& lastBlk = codeBlocks[flit->blockIndex];
    1770                     auto sinfoIt = lastBlk.ssaInfoMap.find(entry.first);
    1771                     Liveness& lv = getLiveness2(entry.first, entry.second, livenesses,
    1772                                 vregIndexMaps, regTypesNum, regRanges);
    1773                    
    1774                     if (lv.contain(codeBlocks[(flowStack.end()-1)->blockIndex].end-1))
    1775                         // already joined (check last byte from last block)
    1776                         continue;
    1777                    
    1778                     size_t lastPos = lastBlk.start;
    1779                     if (sinfoIt != lastBlk.ssaInfoMap.end())
    1780                     {
    1781                         // if begin at some point at last block
    1782                         lastPos = sinfoIt->second.lastPos;
    1783                         lv.insert(lastPos + 1, lastBlk.end);
    1784                         ++flit; // skip last block in stack
    1785                     }
    1786                    
    1787                     for (; flit != flowStack.end(); ++flit)
    1788                     {
    1789                         const CodeBlock& cblock = codeBlocks[flit->blockIndex];
    1790                         lv.insert(cblock.start, cblock.end);
    1791                     }
     1730                    joinVRegRecur(flowStack, codeBlocks, routineMap, flowStackStart,
     1731                            entry.first, entry.second, vregIndexMaps,
     1732                            livenesses, regTypesNum, regRanges, false);
    17921733                }
    17931734            }
     
    18631804            else
    18641805            {
    1865                 joinRegVarLivenesses(flowStack, codeBlocks,
     1806                joinRegVarLivenesses(flowStack, codeBlocks, routineMap,
    18661807                        prevWaysIndexMap, waysToCache, cblocksToCache,
    18671808                        joinFirstPointsCache, joinSecondPointsCache,
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.h

    r4098 r4099  
    376376    bool contain(size_t t) const
    377377    {
     378        if (l.empty())
     379            return false;
    378380        auto it = l.lower_bound(t);
    379381        if (it==l.begin() && it->first>t)
Note: See TracChangeset for help on using the changeset viewer.