Changeset 4066 in CLRX


Ignore:
Timestamp:
May 3, 2018, 3:26:21 PM (3 weeks ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Enable joinFirstPointsCache.

File:
1 edited

Legend:

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

    r4065 r4066  
    845845
    846846// add new join second cache entry with readBeforeWrite for all encountered regvars
    847 static void addJoinSecCacheEntry(const RoutineMap& routineMap,
     847static void addJoinSecCacheEntry(//const RoutineMap& routineMap,
    848848                const std::vector<CodeBlock>& codeBlocks,
    849                 SimpleCache<size_t, SVRegMap>& resSecondPointsCache,
     849                SimpleCache<size_t, SVRegMap>& joinSecondPointsCache,
    850850                size_t nextBlock)
    851851{
     
    874874               
    875875                const SVRegMap* resSecondPoints =
    876                             resSecondPointsCache.use(entry.blockIndex);
     876                            joinSecondPointsCache.use(entry.blockIndex);
    877877                if (resSecondPoints == nullptr)
    878878                {
     
    932932        {
    933933            // add toResolveMap ssaIds inside called routines
    934             for (const auto& next: cblock.nexts)
    935                 if (next.isCall)
    936                 {
    937                     const RoutineData& rdata = routineMap.find(next.block)->second;
    938                     for (const auto& v: rdata.rbwSSAIdMap)
    939                         alreadyReadMap.insert({v.first, entry.blockIndex });
    940                     for (const auto& v: rdata.lastSSAIdMap)
    941                         alreadyReadMap.insert({v.first, entry.blockIndex });
    942                 }
    943            
    944             flowStack.push_back({ entry.blockIndex+1, 0 });
    945             entry.nextIndex++;
    946         }
    947         else // back
    948         {
    949             // remove old to resolve in leaved way to allow collecting next ssaId
    950             // before write (can be different due to earlier visit)
    951             for (const auto& next: cblock.nexts)
    952                 if (next.isCall)
    953                 {
    954                     const RoutineData& rdata = routineMap.find(next.block)->second;
    955                     for (const auto& v: rdata.rbwSSAIdMap)
    956                     {
    957                         auto it = alreadyReadMap.find(v.first);
    958                         if (it != alreadyReadMap.end() && it->second == entry.blockIndex)
    959                             alreadyReadMap.erase(it);
    960                     }
    961                     for (const auto& v: rdata.lastSSAIdMap)
    962                     {
    963                         auto it = alreadyReadMap.find(v.first);
    964                         if (it != alreadyReadMap.end() && it->second == entry.blockIndex)
    965                             alreadyReadMap.erase(it);
    966                     }
    967                 }
    968            
    969             for (const auto& sentry: cblock.ssaInfoMap)
    970             {
    971                 auto it = alreadyReadMap.find(sentry.first);
    972                 if (it != alreadyReadMap.end() && it->second == entry.blockIndex)
    973                     // remove old to resolve in leaved way to allow collecting next ssaId
    974                     // before write (can be different due to earlier visit)
    975                     alreadyReadMap.erase(it);
    976             }
    977             ARDOut << "  popjoin (cache)\n";
    978             flowStack.pop_back();
    979         }
    980     }
    981    
    982     resSecondPointsCache.put(nextBlock, cacheSecPoints);
    983 }
    984 
    985 static void joinRegVarLivenesses(const std::deque<FlowStackEntry3>& prevFlowStack,
    986         const std::vector<CodeBlock>& codeBlocks, const VarIndexMap* vregIndexMaps,
    987         std::vector<Liveness>* livenesses, size_t regTypesNum, const cxuint* regRanges)
    988 {
    989     size_t nextBlock = prevFlowStack.back().blockIndex;
    990     auto pfEnd = prevFlowStack.end();
    991     --pfEnd;
    992     ARDOut << "startJoinLv: " << (pfEnd-1)->blockIndex << "," << nextBlock << "\n";
    993     // key - varreg, value - last position in previous flowStack
    994     SVRegMap stackVarMap;
    995    
    996     for (auto pfit = prevFlowStack.begin(); pfit != pfEnd; ++pfit)
    997     {
    998         const FlowStackEntry3& entry = *pfit;
    999         const CodeBlock& cblock = codeBlocks[entry.blockIndex];
    1000         for (const auto& sentry: cblock.ssaInfoMap)
    1001             stackVarMap[sentry.first] = pfit - prevFlowStack.begin();
    1002     }
    1003    
    1004     // traverse by graph from next block
    1005     std::deque<FlowStackEntry3> flowStack;
    1006     flowStack.push_back({ nextBlock, 0 });
    1007     std::vector<bool> visited(codeBlocks.size(), false);
    1008    
    1009     // already read in current path
    1010     // key - vreg, value - source block where vreg of conflict found
    1011     SVRegMap alreadyReadMap;
    1012    
    1013     while (!flowStack.empty())
    1014     {
    1015         FlowStackEntry3& entry = flowStack.back();
    1016         const CodeBlock& cblock = codeBlocks[entry.blockIndex];
    1017        
    1018         if (entry.nextIndex == 0)
    1019         {
    1020             // process current block
    1021             //if (!visited[entry.blockIndex])
    1022             {
    1023                 //visited[entry.blockIndex] = true;
    1024                 ARDOut << "  lvjoin: " << entry.blockIndex << "\n";
    1025                 for (const auto& sentry: cblock.ssaInfoMap)
    1026                 {
    1027                     const SSAInfo& sinfo = sentry.second;
    1028                     auto res = alreadyReadMap.insert({ sentry.first, entry.blockIndex });
    1029                    
    1030                     if (res.second && sinfo.readBeforeWrite)
    1031                         joinSVregWithVisited(&stackVarMap, sentry.first,
    1032                             sentry.second.ssaIdBefore, prevFlowStack, codeBlocks,
    1033                             vregIndexMaps, livenesses, regTypesNum, regRanges);
    1034                 }
    1035             }
    1036             /*else
    1037             {
    1038                 flowStack.pop_back();
    1039                 continue;
    1040             }*/
    1041         }
    1042        
    1043         if (entry.nextIndex < cblock.nexts.size())
    1044         {
    1045             flowStack.push_back({ cblock.nexts[entry.nextIndex].block, 0 });
    1046             entry.nextIndex++;
    1047         }
    1048         else if (((entry.nextIndex==0 && cblock.nexts.empty()) ||
    1049                 // if have any call then go to next block
    1050                 (cblock.haveCalls && entry.nextIndex==cblock.nexts.size())) &&
    1051                  !cblock.haveReturn && !cblock.haveEnd)
    1052         {
    1053             // add toResolveMap ssaIds inside called routines
    1054934            /*for (const auto& next: cblock.nexts)
    1055935                if (next.isCall)
     
    1095975                    alreadyReadMap.erase(it);
    1096976            }
     977            ARDOut << "  popjoin (cache)\n";
     978            flowStack.pop_back();
     979        }
     980    }
     981   
     982    joinSecondPointsCache.put(nextBlock, cacheSecPoints);
     983}
     984
     985static void joinRegVarLivenesses(const std::deque<FlowStackEntry3>& prevFlowStack,
     986        const std::vector<CodeBlock>& codeBlocks,
     987        const PrevWaysIndexMap& prevWaysIndexMap,
     988        const std::vector<bool>& waysToCache, ResSecondPointsToCache& cblocksToCache,
     989        SimpleCache<size_t, SVRegMap>& joinFirstPointsCache,
     990        SimpleCache<size_t, SVRegMap>& joinSecondPointsCache,
     991        const VarIndexMap* vregIndexMaps,
     992        std::vector<Liveness>* livenesses, size_t regTypesNum, const cxuint* regRanges)
     993{
     994    size_t nextBlock = prevFlowStack.back().blockIndex;
     995    auto pfEnd = prevFlowStack.end();
     996    --pfEnd;
     997    ARDOut << "startJoinLv: " << (pfEnd-1)->blockIndex << "," << nextBlock << "\n";
     998    // key - varreg, value - last position in previous flowStack
     999    SVRegMap stackVarMap;
     1000   
     1001    size_t pfStartIndex = 0;
     1002    {
     1003        auto pfPrev = pfEnd;
     1004        --pfPrev;
     1005        auto it = prevWaysIndexMap.find(pfPrev->blockIndex);
     1006        if (it != prevWaysIndexMap.end())
     1007        {
     1008            const SVRegMap* cached = joinFirstPointsCache.use(it->second.first);
     1009            if (cached!=nullptr)
     1010            {
     1011                ARDOut << "use pfcached: " << it->second.first << ", " <<
     1012                        it->second.second << "\n";
     1013                stackVarMap = *cached;
     1014                pfStartIndex = it->second.second+1;
     1015               
     1016                // apply missing calls at end of the cached
     1017                //const CodeBlock& cblock = codeBlocks[it->second.first];
     1018               
     1019                //const FlowStackEntry3& entry = *(prevFlowStack.begin()+pfStartIndex-1);
     1020                //if (entry.nextIndex > cblock.nexts.size())
     1021                   // applyCallToStackVarMap(cblock, routineMap, stackVarMap, -1, -1);
     1022            }
     1023        }
     1024    }
     1025   
     1026    for (auto pfit = prevFlowStack.begin(); pfit != pfEnd; ++pfit)
     1027    {
     1028        const FlowStackEntry3& entry = *pfit;
     1029        const CodeBlock& cblock = codeBlocks[entry.blockIndex];
     1030        for (const auto& sentry: cblock.ssaInfoMap)
     1031            stackVarMap[sentry.first] = pfit - prevFlowStack.begin();
     1032       
     1033        // put to first point cache
     1034        if (waysToCache[pfit->blockIndex] &&
     1035            !joinFirstPointsCache.hasKey(pfit->blockIndex))
     1036        {
     1037            ARDOut << "put pfcache " << pfit->blockIndex << "\n";
     1038            joinFirstPointsCache.put(pfit->blockIndex, stackVarMap);
     1039        }
     1040    }
     1041   
     1042    // traverse by graph from next block
     1043    std::deque<FlowStackEntry3> flowStack;
     1044    flowStack.push_back({ nextBlock, 0 });
     1045    std::vector<bool> visited(codeBlocks.size(), false);
     1046   
     1047    // already read in current path
     1048    // key - vreg, value - source block where vreg of conflict found
     1049    SVRegMap alreadyReadMap;
     1050   
     1051    while (!flowStack.empty())
     1052    {
     1053        FlowStackEntry3& entry = flowStack.back();
     1054        const CodeBlock& cblock = codeBlocks[entry.blockIndex];
     1055       
     1056        if (entry.nextIndex == 0)
     1057        {
     1058            // process current block
     1059            //if (!visited[entry.blockIndex])
     1060            {
     1061                //visited[entry.blockIndex] = true;
     1062                ARDOut << "  lvjoin: " << entry.blockIndex << "\n";
     1063                for (const auto& sentry: cblock.ssaInfoMap)
     1064                {
     1065                    const SSAInfo& sinfo = sentry.second;
     1066                    auto res = alreadyReadMap.insert({ sentry.first, entry.blockIndex });
     1067                   
     1068                    if (res.second && sinfo.readBeforeWrite)
     1069                        joinSVregWithVisited(&stackVarMap, sentry.first,
     1070                            sentry.second.ssaIdBefore, prevFlowStack, codeBlocks,
     1071                            vregIndexMaps, livenesses, regTypesNum, regRanges);
     1072                }
     1073            }
     1074            /*else
     1075            {
     1076                flowStack.pop_back();
     1077                continue;
     1078            }*/
     1079        }
     1080       
     1081        if (entry.nextIndex < cblock.nexts.size())
     1082        {
     1083            flowStack.push_back({ cblock.nexts[entry.nextIndex].block, 0 });
     1084            entry.nextIndex++;
     1085        }
     1086        else if (((entry.nextIndex==0 && cblock.nexts.empty()) ||
     1087                // if have any call then go to next block
     1088                (cblock.haveCalls && entry.nextIndex==cblock.nexts.size())) &&
     1089                 !cblock.haveReturn && !cblock.haveEnd)
     1090        {
     1091            // add toResolveMap ssaIds inside called routines
     1092            /*for (const auto& next: cblock.nexts)
     1093                if (next.isCall)
     1094                {
     1095                    const RoutineData& rdata = routineMap.find(next.block)->second;
     1096                    for (const auto& v: rdata.rbwSSAIdMap)
     1097                        alreadyReadMap.insert({v.first, entry.blockIndex });
     1098                    for (const auto& v: rdata.lastSSAIdMap)
     1099                        alreadyReadMap.insert({v.first, entry.blockIndex });
     1100                }*/
     1101           
     1102            flowStack.push_back({ entry.blockIndex+1, 0 });
     1103            entry.nextIndex++;
     1104        }
     1105        else // back
     1106        {
     1107            // remove old to resolve in leaved way to allow collecting next ssaId
     1108            // before write (can be different due to earlier visit)
     1109            /*for (const auto& next: cblock.nexts)
     1110                if (next.isCall)
     1111                {
     1112                    const RoutineData& rdata = routineMap.find(next.block)->second;
     1113                    for (const auto& v: rdata.rbwSSAIdMap)
     1114                    {
     1115                        auto it = alreadyReadMap.find(v.first);
     1116                        if (it != alreadyReadMap.end() && it->second == entry.blockIndex)
     1117                            alreadyReadMap.erase(it);
     1118                    }
     1119                    for (const auto& v: rdata.lastSSAIdMap)
     1120                    {
     1121                        auto it = alreadyReadMap.find(v.first);
     1122                        if (it != alreadyReadMap.end() && it->second == entry.blockIndex)
     1123                            alreadyReadMap.erase(it);
     1124                    }
     1125                }*/
     1126           
     1127            for (const auto& sentry: cblock.ssaInfoMap)
     1128            {
     1129                auto it = alreadyReadMap.find(sentry.first);
     1130                if (it != alreadyReadMap.end() && it->second == entry.blockIndex)
     1131                    // remove old to resolve in leaved way to allow collecting next ssaId
     1132                    // before write (can be different due to earlier visit)
     1133                    alreadyReadMap.erase(it);
     1134            }
    10971135            ARDOut << "  popjoin\n";
    10981136           
    10991137            /*if (cblocksToCache.count(entry.blockIndex)==2 &&
    1100                 !resSecondPointsCache.hasKey(entry.blockIndex))
     1138                !joinSecondPointsCache.hasKey(entry.blockIndex))
    11011139                // add to cache
    1102                 addResSecCacheEntry(routineMap, codeBlocks, resSecondPointsCache,
     1140                addResSecCacheEntry(routineMap, codeBlocks, joinSecondPointsCache,
    11031141                            entry.blockIndex);*/
    11041142           
     
    14451483    // after, that resolve joins (join with already visited code)
    14461484    // SVRegMap in this cache: key - vreg, value - last flowStack entry position
    1447     SimpleCache<size_t, SVRegMap> resFirstPointsCache(wrCount<<1);
     1485    SimpleCache<size_t, SVRegMap> joinFirstPointsCache(wrCount<<1);
    14481486    // SVRegMap in this cache: key - vreg, value - first readBefore in second part
    1449     SimpleCache<size_t, SVRegMap> resSecondPointsCache(rbwCount<<1);
     1487    SimpleCache<size_t, SVRegMap> joinSecondPointsCache(rbwCount<<1);
    14501488   
    14511489    flowStack.clear();
     
    14661504            else
    14671505            {
    1468                 joinRegVarLivenesses(flowStack, codeBlocks, vregIndexMaps,
    1469                             livenesses, regTypesNum, regRanges);
     1506                joinRegVarLivenesses(flowStack, codeBlocks,
     1507                        prevWaysIndexMap, waysToCache, cblocksToCache,
     1508                        joinFirstPointsCache, joinSecondPointsCache,
     1509                        vregIndexMaps, livenesses, regTypesNum, regRanges);
    14701510                // back, already visited
    14711511                flowStack.pop_back();
     
    14891529        else // back
    14901530        {
    1491             /*if (cblocksToCache.count(entry.blockIndex)==2 &&
    1492                 !resSecondPointsCache.hasKey(entry.blockIndex))
     1531            if (cblocksToCache.count(entry.blockIndex)==2 &&
     1532                !joinSecondPointsCache.hasKey(entry.blockIndex))
    14931533                // add to cache
    1494                 addResSecCacheEntry(routineMap, codeBlocks, resSecondPointsCache,
    1495                             entry.blockIndex);*/
     1534                addJoinSecCacheEntry(codeBlocks, joinSecondPointsCache,
     1535                            entry.blockIndex);
    14961536            flowStack.pop_back();
    14971537        }
Note: See TracChangeset for help on using the changeset viewer.