Changeset 4165 in CLRX


Ignore:
Timestamp:
May 15, 2018, 7:01:47 AM (3 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Add some debug dumps to AsmRegAllocLive?. Some fix in some testcase. Fix the second passing through recursion.

Location:
CLRadeonExtender/trunk
Files:
2 edited

Legend:

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

    r4164 r4165  
    363363    }
    364364   
    365     if (flitEnd != flowStack.begin())
    366     {
    367         const CodeBlock& cbLast = codeBlocks[(flitEnd-1)->blockIndex.index];
    368         if (lv.contain(cbLast.end-1))
    369             // if already filled up
    370             return;
    371     }
    372    
    373365    auto flit = flowStack.begin() + flowStkStart.stackPos;
    374366    // applyVIdx to call entry (if needed, and if some join inside subroutines)
     
    923915        const std::unordered_map<size_t, VIdxSetEntry>& vidxRoutineMap,
    924916        RoutineDataLv& rdata, VIdxSetEntry& routineVIdxes,
    925         size_t routineBlock, const VarIndexMap* vregIndexMaps,
     917        BlockIndex routineBlock, const VarIndexMap* vregIndexMaps,
    926918        size_t regTypesNum, const cxuint* regRanges)
    927919{
     920    ARDOut << "--------- createRoutineDataLv(" << routineBlock << ")\n";
    928921    std::deque<FlowStackEntry4> flowStack;
    929922    std::unordered_set<size_t> visited;
     
    937930   
    938931    bool notFirstReturn = false;
    939     flowStack.push_back({ routineBlock, 0 });
     932    flowStack.push_back({ routineBlock.index, 0 });
    940933    RoutineCurAccessMap curSVRegMap; // key - svreg, value - block index
    941934   
     
    950943            if (visited.insert(entry.blockIndex).second)
    951944            {
     945                ARDOut << "  cpjproc: " << entry.blockIndex << "\n";
     946               
    952947                for (const auto& sentry: cblock.ssaInfoMap)
    953948                {
     
    10151010                        cblock.nexts[entry.nextIndex].isCall; entry.nextIndex++)
    10161011            {
    1017                 size_t rblock = cblock.nexts[entry.nextIndex].block;
     1012                BlockIndex rblock(cblock.nexts[entry.nextIndex].block, routineBlock.pass);
    10181013                if (rblock != routineBlock &&
    1019                     recurseBlocks.find(rblock) == recurseBlocks.end())
    1020                     calledRoutines.push_back(rblock);
     1014                    recurseBlocks.find(rblock.index) == recurseBlocks.end())
     1015                    calledRoutines.push_back(rblock.index);
    10211016            }
    10221017           
     
    11181113    for (const AsmSingleVReg& svreg: vregsNotInAllRets)
    11191114    {
    1120         auto res = rdata.lastAccessMap.insert({ svreg, { { routineBlock, false } } });
     1115        auto res = rdata.lastAccessMap.insert(
     1116                    { svreg, { { routineBlock.index, false } } });
    11211117        if (!res.second)
    11221118        {
    11231119            VectorSet<LastAccessBlockPos>& sset = res.first->second;
    1124             // filter before inserting (remove everything that do not point to calls)
    1125             /*sset.resize(std::remove_if(sset.begin(), sset.end(),
    1126                 [](const LastAccessBlockPos& b)
    1127                 { return !b.inSubroutines; }) - sset.begin());*/
    1128             sset.insertValue({ routineBlock, false });
     1120            sset.insertValue({ routineBlock.index, false });
    11291121        }
    11301122    }
     
    12311223    flowStack.push_back({ 0, 0 });
    12321224   
    1233     bool doNotCreateRoutine = false;
    12341225    while (!flowStack.empty())
    12351226    {
     
    13771368        {
    13781369            ARDOut << " ret: " << entry.blockIndex << "\n";
    1379             // check whether doNotCreateRoutine if yes then skip and only pop call stack
    1380             if (!doNotCreateRoutine)
    1381             {
    1382             const size_t routineBlock = callStack.back().routineBlock.index;
    1383             auto res = routineMap.insert({ routineBlock, { } });
    1384            
    1385             // while second pass in recursion: the routine's insertion was happened
    1386             // later in first pass (after return from second pass)
    1387             // we check whether second pass happened for this routine
     1370            const BlockIndex routineBlock = callStack.back().routineBlock;
     1371            auto res = routineMap.insert({ routineBlock.index, { } });
     1372           
    13881373            if (res.second || res.first->second.inSecondPass)
    13891374            {
    1390                 res.first->second.inSecondPass = callStack.back().routineBlock.pass==1;
    1391                
    1392                 auto varRes = vidxRoutineMap.insert({ routineBlock, VIdxSetEntry{} });
     1375                res.first->second.inSecondPass = routineBlock.pass==1;
     1376                auto varRes = vidxRoutineMap.insert({ routineBlock.index, VIdxSetEntry{} });
    13931377                createRoutineDataLv(codeBlocks, routineMap, recurseBlocks, vidxRoutineMap,
    13941378                        res.first->second, varRes.first->second,
    1395                         routineBlock, vregIndexMaps, regTypesNum, regRanges);
     1379                        routineBlock.index, vregIndexMaps, regTypesNum, regRanges);
    13961380            }
    13971381            else
     
    14121396            }
    14131397            callBlocks.erase(routineBlock);
    1414             }
    14151398            callStack.pop_back(); // just return from call
    14161399        }
    1417        
    1418         doNotCreateRoutine = false;
    14191400       
    14201401        if (entry.nextIndex < cblock.nexts.size())
     
    14241405            if (cblock.nexts[entry.nextIndex].isCall)
    14251406            {
     1407                if (!callBlocks.insert(nextBlock).second)
     1408                {
     1409                    // just skip recursion (is good?)
     1410                    if (recurseBlocks.insert(nextBlock.index).second)
     1411                    {
     1412                        ARDOut << "   -- recursion: " << nextBlock << "\n";
     1413                        nextBlock.pass = 1;
     1414                    }
     1415                    else if (entry.blockIndex.pass==1)
     1416                    {
     1417                        /// mark that is routine call to skip
     1418                        entry.nextIndex++;
     1419                        continue;
     1420                    }
     1421                }
     1422                else if (entry.blockIndex.pass==1 &&
     1423                    recurseBlocks.find(nextBlock.index) != recurseBlocks.end())
     1424                {
     1425                    /// mark that is routine call to skip
     1426                    entry.nextIndex++;
     1427                    continue;
     1428                }
     1429               
    14261430                callStack.push_back({ entry.blockIndex,
    14271431                            entry.nextIndex, nextBlock });
    1428                
    1429                 if (!callBlocks.insert(nextBlock).second)
    1430                 {
    1431                     // just skip recursion (is good?)
    1432                     if (recurseBlocks.insert(nextBlock.index).second)
    1433                     {
    1434                         ARDOut << "   -- recursion: " << nextBlock << "\n";
    1435                         nextBlock.pass = 1;
    1436                     }
    1437                     else if (entry.blockIndex.pass==1)
    1438                     {
    1439                         /// mark that is routine call to skip
    1440                         doNotCreateRoutine = true;
    1441                         entry.nextIndex++;
    1442                         continue;
    1443                     }
    1444                 }
    1445                 else if (entry.blockIndex.pass==1 &&
    1446                     recurseBlocks.find(nextBlock.index) != recurseBlocks.end())
    1447                 {
    1448                     /// mark that is routine call to skip
    1449                     doNotCreateRoutine = true;
    1450                     entry.nextIndex++;
    1451                     continue;
    1452                 }
    14531432            }
    14541433           
  • CLRadeonExtender/trunk/tests/amdasm/AsmRegAlloc3.cpp

    r4163 r4165  
    24852485        {   // vidxCallMap
    24862486            { 0, { { { 2, 3, 6, 7, 16 }, { }, { }, { } } } },
    2487             { 5, { { { 6 }, { }, { }, { } } } }
     2487            { 5, { { { 6, 7 }, { }, { }, { } } } }
    24882488        },
    24892489        true, ""
     
    29062906static void testCreateLivenessesCase(cxuint i, const AsmLivenessesCase& testCase)
    29072907{
     2908    std::cout << "-----------------------------------------------\n"
     2909    "           Test " << i << "\n"
     2910                "------------------------------------------------\n";
     2911   
    29082912    std::istringstream input(testCase.input);
    29092913    std::ostringstream errorStream;
Note: See TracChangeset for help on using the changeset viewer.