Changeset 3950 in CLRX


Ignore:
Timestamp:
Mar 29, 2018, 3:58:58 PM (4 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Tentatively working recursion support (only single testcase).

Location:
CLRadeonExtender/trunk
Files:
2 edited

Legend:

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

    r3949 r3950  
    831831            {
    832832                visited[entry.blockIndex] = true;
    833                 std::cout << "  resolv: " << entry.blockIndex << std::endl;
     833                std::cout << "  resolv (cache): " << entry.blockIndex << std::endl;
    834834               
    835835                const RBWSSAIdMap* resSecondPoints =
     
    851851            {
    852852                // back, already visited
    853                 std::cout << "resolv already: " << entry.blockIndex << std::endl;
     853                std::cout << "resolv already (cache): " << entry.blockIndex << std::endl;
    854854                flowStack.pop_back();
    855855                continue;
     
    911911                    alreadyReadMap.erase(it);
    912912            }
    913             std::cout << "  popresolv" << std::endl;
     913            std::cout << "  popresolv (cache)" << std::endl;
    914914            flowStack.pop_back();
    915915        }
     
    16001600
    16011601static void createRoutineData(const std::vector<CodeBlock>& codeBlocks,
     1602        SSAReplacesMap& ssaReplacesMap,
    16021603        std::unordered_map<AsmSingleVReg, size_t>& curSSAIdMap,
    16031604        const std::unordered_set<size_t>& loopBlocks,
     
    16241625    if (!prevFlowStackBlocks.empty())
    16251626        flowStackBlocks = prevFlowStackBlocks;
     1627   
     1628    // SSAId for join recursion returns
     1629    RoutineData retRecurRdata;
    16261630    // last SSA ids map from returns
    16271631    RetSSAIdMap retSSAIdMap;
     
    16291633    flowStackBlocks[routineBlock] = true;
    16301634   
     1635    bool returnFromRecur = (retRecurState != nullptr);
    16311636    if (retRecurState != nullptr)
    16321637    {
     
    16541659                {
    16551660                    RoutineData* subRdata = subroutinesCache.use(entry.blockIndex);
     1661                    if (returnFromRecur)
     1662                        joinLastSSAIdMap(retRecurRdata.lastSSAIdMap,
     1663                                    loopsit2->second.ssaIdMap, *subRdata, true);
     1664                   
    16561665                    joinLastSSAIdMap(rdata.lastSSAIdMap, loopsit2->second.ssaIdMap,
    16571666                                        *subRdata, true);
     
    16631672            const bool oldFB = flowStackBlocks[entry.blockIndex];
    16641673            flowStackBlocks[entry.blockIndex] = !oldFB;
    1665             createRoutineData(codeBlocks, curSSAIdMap, loopBlocks, recurBlocks,
    1666                     subroutToCache, subroutinesCache, routineMap, routineMapRecur,
    1667                     retRecurStateMapMap, subrData, entry.blockIndex,
     1674            createRoutineData(codeBlocks, ssaReplacesMap, curSSAIdMap, loopBlocks,
     1675                    recurBlocks, subroutToCache, subroutinesCache, routineMap,
     1676                    routineMapRecur, retRecurStateMapMap, subrData, entry.blockIndex,
    16681677                    true, flowStackBlocks);
    16691678            RoutineData subrDataCopy;
     
    16831692                    std::cout << "   loopssaIdMap2End: " << std::endl;
    16841693                    if (applyToMainRoutine)
     1694                    {
     1695                        if (returnFromRecur)
     1696                            joinLastSSAIdMap(retRecurRdata.lastSSAIdMap,
     1697                                    loopsit2->second.ssaIdMap, subrDataCopy, true);
    16851698                        joinLastSSAIdMap(rdata.lastSSAIdMap, loopsit2->second.ssaIdMap,
    16861699                                        subrDataCopy, true);
     1700                    }
    16871701                }
    16881702            }
     
    17781792                std::cout << "use cached subr " << entry.blockIndex << std::endl;
    17791793                std::cout << "procret2: " << entry.blockIndex << std::endl;
     1794                if (returnFromRecur)
     1795                    joinLastSSAIdMap(retRecurRdata.lastSSAIdMap,
     1796                            retRecurRdata.curSSAIdMap, *cachedRdata);
     1797               
    17801798                joinLastSSAIdMap(rdata.lastSSAIdMap, rdata.curSSAIdMap, *cachedRdata);
    17811799                // get not given rdata curSSAIdMap ssaIds but present in cachedRdata
    17821800                // curSSAIdMap
    17831801                for (const auto& entry: cachedRdata->curSSAIdMap)
     1802                {
    17841803                    if (rdata.curSSAIdMap.find(entry.first) == rdata.curSSAIdMap.end())
    17851804                    {
    17861805                        auto cit = curSSAIdMap.find(entry.first);
    17871806                        size_t prevSSAId = (cit!=curSSAIdMap.end() ? cit->second : 1)-1;
     1807                       
    17881808                        rdata.curSSAIdMap.insert({ entry.first, { prevSSAId } });
    17891809                       
     
    17961816                        }
    17971817                    }
     1818                    if (returnFromRecur && retRecurRdata.curSSAIdMap.find(entry.first) ==
     1819                                retRecurRdata.curSSAIdMap.end())
     1820                    {
     1821                        auto cit = curSSAIdMap.find(entry.first);
     1822                        size_t prevSSAId = (cit!=curSSAIdMap.end() ? cit->second : 1)-1;
     1823                       
     1824                        retRecurRdata.curSSAIdMap.insert(
     1825                                    { entry.first, { prevSSAId } });
     1826                        retRecurRdata.lastSSAIdMap.insertSSAId(entry.first, prevSSAId);
     1827                    }
     1828                }
    17981829               
    17991830                // join loopEnds
     
    18181849                    for (size_t loop: activeLoops)
    18191850                    {
    1820                         auto res = loopSubrsMap.insert({ loop, { entry.blockIndex} });
     1851                        auto res = loopSubrsMap.insert({ loop, { entry.blockIndex } });
    18211852                        if (!res.second)
    18221853                            res.first->second.insertValue(entry.blockIndex);
     
    18321863                    if (ssaEntry.first.regVar != nullptr)
    18331864                    {
     1865                        if (returnFromRecur)
     1866                            updateRoutineData(retRecurRdata, ssaEntry,
     1867                                        curSSAIdMap[ssaEntry.first]-1);
     1868                       
    18341869                        // put data to routine data
    18351870                        updateRoutineData(rdata, ssaEntry, curSSAIdMap[ssaEntry.first]-1);
     
    18621897            //joinRoutineData(rdata, routineMap.find(
    18631898            //                cblock.nexts[entry.nextIndex].block)->second);
     1899            if (returnFromRecur && recurBlocks.find(nextRBlock) == recurBlocks.end())
     1900                joinRoutineData(retRecurRdata, *findRoutine(routineMap,
     1901                                routineMapRecur, nextRBlock));
    18641902            joinRoutineData(rdata, *findRoutine(routineMap, routineMapRecur, nextRBlock));
    18651903        }
     
    19161954            {
    19171955                std::cout << "procret: " << entry.blockIndex << std::endl;
     1956                if (returnFromRecur)
     1957                    joinLastSSAIdMap(retRecurRdata.lastSSAIdMap, retRecurRdata.curSSAIdMap);
    19181958                joinLastSSAIdMap(rdata.lastSSAIdMap, rdata.curSSAIdMap);
    19191959                std::cout << "procretend" << std::endl;
    19201960                rdata.notFirstReturn = true;
     1961                if (returnFromRecur)
     1962                    retRecurRdata.notFirstReturn = true;
    19211963            }
    19221964           
    19231965            // revert retSSAIdMap
     1966            if (returnFromRecur)
     1967                revertRetSSAIdMap(curSSAIdMap, retSSAIdMap, entry, &retRecurRdata);
     1968           
    19241969            revertRetSSAIdMap(curSSAIdMap, retSSAIdMap, entry, &rdata);
    19251970            //
     
    19381983                            nextSSAId << ", " << curSSAId << std::endl;
    19391984               
     1985                if (returnFromRecur)
     1986                    updateRoutineCurSSAIdMap(&retRecurRdata, ssaEntry, entry,
     1987                                    curSSAId, nextSSAId);
    19401988                updateRoutineCurSSAIdMap(&rdata, ssaEntry, entry, curSSAId, nextSSAId);
    19411989            }
     
    19722020        }
    19732021    }
     2022   
     2023    if (returnFromRecur)
     2024    {
     2025        for (const auto& entry: retRecurRdata.rbwSSAIdMap)
     2026        {
     2027            auto lit = retRecurRdata.lastSSAIdMap.find(entry.first);
     2028            if (lit != retRecurRdata.lastSSAIdMap.end())
     2029                for (size_t ssaId: lit->second)
     2030                {
     2031                    if (entry.second < ssaId)
     2032                        insertReplace(ssaReplacesMap, entry.first, ssaId, entry.second);
     2033                    else if (entry.second > ssaId)
     2034                        insertReplace(ssaReplacesMap, entry.first, entry.second, ssaId);
     2035                }
     2036        }
     2037    }
    19742038    std::cout << "--------- createRoutineData end ------------\n";
    19752039}
     
    20332097            if (!isRoutineGen[routineBlock])
    20342098            {
    2035                 createRoutineData(codeBlocks, curSSAIdMap, loopBlocks, recurseBlocks,
     2099                createRoutineData(codeBlocks, ssaReplacesMap, curSSAIdMap,
     2100                        loopBlocks, recurseBlocks,
    20362101                        cblocksToCache, subroutinesCache, routineMap, &routineMapSP,
    20372102                        retRecurStateMapMap, prevRdata, routineBlock,
     
    21162181   
    21172182    rdataSP = routineMapSP.find(recurBlock)->second;
    2118     createRoutineData(codeBlocks, curSSAIdMap, loopBlocks, recurseBlocks, cblocksToCache,
    2119                 subroutinesCache, routineMap, &routineMapSP,
    2120                 retRecurStateMapMap, rdataSP, recurBlock);
     2183    createRoutineData(codeBlocks, ssaReplacesMap, curSSAIdMap, loopBlocks,
     2184                recurseBlocks, cblocksToCache, subroutinesCache, routineMap,
     2185                &routineMapSP, retRecurStateMapMap, rdataSP, recurBlock);
    21212186   
    21222187    // replace routineMap entries by routineMapSP entries
     
    23282393            if (!isRoutineGen[routineBlock] && !flowStackBlocks[routineBlock])
    23292394            {
    2330                 createRoutineData(codeBlocks, curSSAIdMap, loopBlocks, recurseBlocks,
    2331                         cblocksToCache, subroutinesCache, routineMap, nullptr,
    2332                         retRecurStateMapMap, prevRdata, routineBlock);
     2395                createRoutineData(codeBlocks, ssaReplacesMap, curSSAIdMap,
     2396                        loopBlocks, recurseBlocks, cblocksToCache, subroutinesCache,
     2397                        routineMap, nullptr, retRecurStateMapMap, prevRdata, routineBlock);
    23332398                //prevRdata.compare(myRoutineData);
    23342399               
     
    23422407                            rsit->second.retSSAIdMap, ssaReplacesMap,
    23432408                            retRecurStateMapMap, routineBlock, rdataSP);
    2344                     recurseBlocks.erase(routineBlock);
    23452409                    // join retRecurStates
    23462410                    for (auto& entry: retRecurStateMapMap[routineBlock])
    23472411                    {
    23482412                        std::cout << "join retrecState: " << entry.first << std::endl;
    2349                         createRoutineData(codeBlocks, entry.second.curSSAIdMap,
     2413                        createRoutineData(codeBlocks, ssaReplacesMap,
     2414                                entry.second.curSSAIdMap,
    23502415                                loopBlocks, recurseBlocks, cblocksToCache,
    23512416                                subroutinesCache, routineMap, nullptr,
     
    23542419                        joinRoutineData(prevRdata, rdataSP);
    23552420                    }
     2421                    recurseBlocks.erase(routineBlock);
    23562422                }
    23572423               
  • CLRadeonExtender/trunk/tests/amdasm/AsmRegAllocCase3.cpp

    r3941 r3950  
    11871187        true, ""
    11881188    },
    1189 #if 0
    11901189    {   // 7 - first recursion testcase
    11911190        R"ffDXD(.regvar sa:s:8, va:v:8
     
    12171216b0:     s_xor_b32 sa[3], sa[3], sa[0]
    12181217        s_xor_b32 sa[2], sa[2], sa[0]
     1218        s_xor_b32 sa[6], sa[6], sa[0]
    12191219        .cf_ret
    12201220        s_setpc_b64 s[0:1]
    12211221)ffDXD",
    12221222        {
    1223         },
    1224         {
     1223            {   // block 0 - start
     1224                0, 16,
     1225                { { 2, true } },
     1226                {
     1227                    { { "", 0 }, SSAInfo(0, 0, 0, 0, 0, false) },
     1228                    { { "", 1 }, SSAInfo(0, 0, 0, 0, 0, false) },
     1229                    { { "", 2 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1230                    { { "", 3 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1231                    { { "", 4 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1232                    { { "", 7 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1233                    { { "sa", 2 }, SSAInfo(0, 1, 1, 1, 1, false) },
     1234                    { { "sa", 3 }, SSAInfo(0, 1, 1, 1, 1, false) },
     1235                    { { "sa", 6 }, SSAInfo(0, 1, 1, 1, 1, false) }
     1236                }, true, false, false },
     1237            {   // block 1 - end
     1238                16, 32,
     1239                { },
     1240                {
     1241                    { { "sa", 0 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) },
     1242                    { { "sa", 2 }, SSAInfo(2, 4, 4, 4, 1, true) },
     1243                    { { "sa", 3 }, SSAInfo(3, 5, 5, 5, 1, true) },
     1244                    { { "sa", 6 }, SSAInfo(2, 4, 4, 4, 1, true) }
     1245                }, false, false, true },
     1246            {   // block 2 - routine
     1247                32, 44,
     1248                { { 3, false }, { 5, false } },
     1249                {
     1250                    { { "sa", 0 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) },
     1251                    { { "sa", 1 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) },
     1252                    { { "sa", 2 }, SSAInfo(1, 2, 2, 2, 1, true) },
     1253                    { { "sa", 3 }, SSAInfo(1, 2, 2, 2, 1, true) }
     1254                }, false, false, false },
     1255            {   // block 3 - recur call
     1256                44, 48,
     1257                { { 2, true } },
     1258                {
     1259                    { { "", 0 }, SSAInfo(0, 0, 0, 0, 0, false) },
     1260                    { { "", 1 }, SSAInfo(0, 0, 0, 0, 0, false) },
     1261                    { { "", 2 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1262                    { { "", 3 }, SSAInfo(0, 0, 0, 0, 0, true) }
     1263                }, true, false, false },
     1264            {   // block 4 - routine end
     1265                48, 60,
     1266                { },
     1267                {
     1268                    { { "", 0 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1269                    { { "", 1 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1270                    { { "sa", 1 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) },
     1271                    { { "sa", 3 }, SSAInfo(2, 3, 3, 3, 1, true) },
     1272                    { { "sa", 6 }, SSAInfo(1, 2, 2, 2, 1, true) }
     1273                }, false, true, true },
     1274            {   // block 5 - routine end 2
     1275                60, 76,
     1276                { },
     1277                {
     1278                    { { "", 0 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1279                    { { "", 1 }, SSAInfo(0, 0, 0, 0, 0, true) },
     1280                    { { "sa", 0 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) },
     1281                    { { "sa", 2 }, SSAInfo(2, 3, 3, 3, 1, true) },
     1282                    { { "sa", 3 }, SSAInfo(2, 4, 4, 4, 1, true) },
     1283                    { { "sa", 6 }, SSAInfo(1, 3, 3, 3, 1, true) }
     1284                }, false, true, true }
     1285        },
     1286        {   // SSA replaces
     1287            { { "sa", 2 }, { { 3, 2 }, { 2, 1 } } },
     1288            { { "sa", 3 }, { { 3, 2 }, { 4, 3 }, { 2, 1 } } },
     1289            { { "sa", 6 }, { { 2, 1 }, { 3, 2 } } }
    12251290        },
    12261291        true, ""
    12271292    },
    1228 #endif
    12291293    { nullptr }
    12301294};
Note: See TracChangeset for help on using the changeset viewer.