Changeset 4106 in CLRX


Ignore:
Timestamp:
May 7, 2018, 9:08:40 PM (6 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Include routines while joining regvars (joinRegVarLivenesses) and while caching first and second points.

Location:
CLRadeonExtender/trunk/amdasm
Files:
2 edited

Legend:

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

    r4104 r4106  
    931931
    932932// add new join second cache entry with readBeforeWrite for all encountered regvars
    933 static void addJoinSecCacheEntry(//const RoutineMap& routineMap,
     933static void addJoinSecCacheEntry(const RoutineLvMap& routineMap,
    934934                const std::vector<CodeBlock>& codeBlocks,
    935935                SimpleCache<size_t, SVRegMap>& joinSecondPointsCache,
     
    10081008        {
    10091009            // add toResolveMap ssaIds inside called routines
    1010             /*for (const auto& next: cblock.nexts)
     1010            for (const auto& next: cblock.nexts)
    10111011                if (next.isCall)
    10121012                {
    1013                     const RoutineData& rdata = routineMap.find(next.block)->second;
     1013                    const RoutineDataLv& rdata = routineMap.find(next.block)->second;
    10141014                    for (const auto& v: rdata.rbwSSAIdMap)
    10151015                        alreadyReadMap.insert({v.first, entry.blockIndex });
    1016                     for (const auto& v: rdata.lastSSAIdMap)
     1016                    for (const auto& v: rdata.lastAccessMap)
    10171017                        alreadyReadMap.insert({v.first, entry.blockIndex });
    1018                 }*/
     1018                }
    10191019           
    10201020            flowStack.push_back({ entry.blockIndex+1, 0 });
     
    10251025            // remove old to resolve in leaved way to allow collecting next ssaId
    10261026            // before write (can be different due to earlier visit)
    1027             /*for (const auto& next: cblock.nexts)
     1027            for (const auto& next: cblock.nexts)
    10281028                if (next.isCall)
    10291029                {
    1030                     const RoutineData& rdata = routineMap.find(next.block)->second;
     1030                    const RoutineDataLv& rdata = routineMap.find(next.block)->second;
    10311031                    for (const auto& v: rdata.rbwSSAIdMap)
    10321032                    {
     
    10351035                            alreadyReadMap.erase(it);
    10361036                    }
    1037                     for (const auto& v: rdata.lastSSAIdMap)
     1037                    for (const auto& v: rdata.lastAccessMap)
    10381038                    {
    10391039                        auto it = alreadyReadMap.find(v.first);
     
    10411041                            alreadyReadMap.erase(it);
    10421042                    }
    1043                 }*/
     1043                }
    10441044           
    10451045            for (const auto& sentry: cblock.ssaInfoMap)
     
    10591059}
    10601060
     1061// apply calls (changes from these calls) from code blocks to stack var map
     1062static void applyCallToStackVarMap(const CodeBlock& cblock, const RoutineLvMap& routineMap,
     1063        LastStackPosMap& stackVarMap, size_t pfPos, size_t nextIndex)
     1064{
     1065    for (const NextBlock& next: cblock.nexts)
     1066        if (next.isCall)
     1067        {
     1068            ARDOut << "  japplycall: " << pfPos << ": " <<
     1069                    nextIndex << ": " << next.block << "\n";
     1070            const LastAccessMap& regVarMap =
     1071                    routineMap.find(next.block)->second.lastAccessMap;
     1072            for (const auto& sentry: regVarMap)
     1073                stackVarMap[sentry.first] = LastVRegStackPos{ pfPos, true };
     1074        }
     1075}
     1076
    10611077static void joinRegVarLivenesses(const std::deque<FlowStackEntry3>& prevFlowStack,
    10621078        const std::vector<CodeBlock>& codeBlocks, const RoutineLvMap& routineMap,
    10631079        const PrevWaysIndexMap& prevWaysIndexMap,
    10641080        const std::vector<bool>& waysToCache, ResSecondPointsToCache& cblocksToCache,
    1065         SimpleCache<size_t, SVRegMap>& joinFirstPointsCache,
     1081        SimpleCache<size_t, LastStackPosMap>& joinFirstPointsCache,
    10661082        SimpleCache<size_t, SVRegMap>& joinSecondPointsCache,
    10671083        const VarIndexMap* vregIndexMaps,
     
    10731089    ARDOut << "startJoinLv: " << (pfEnd-1)->blockIndex << "," << nextBlock << "\n";
    10741090    // key - varreg, value - last position in previous flowStack
    1075     SVRegMap stackVarMap;
     1091    LastStackPosMap stackVarMap;
    10761092   
    10771093    size_t pfStartIndex = 0;
     
    10821098        if (it != prevWaysIndexMap.end())
    10831099        {
    1084             const SVRegMap* cached = joinFirstPointsCache.use(it->second.first);
     1100            const LastStackPosMap* cached = joinFirstPointsCache.use(it->second.first);
    10851101            if (cached!=nullptr)
    10861102            {
     
    10911107               
    10921108                // apply missing calls at end of the cached
    1093                 //const CodeBlock& cblock = codeBlocks[it->second.first];
     1109                const CodeBlock& cblock = codeBlocks[it->second.first];
    10941110               
    1095                 //const FlowStackEntry3& entry = *(prevFlowStack.begin()+pfStartIndex-1);
    1096                 //if (entry.nextIndex > cblock.nexts.size())
    1097                    // applyCallToStackVarMap(cblock, routineMap, stackVarMap, -1, -1);
     1111                const FlowStackEntry3& entry = *(prevFlowStack.begin()+pfStartIndex-1);
     1112                if (entry.nextIndex > cblock.nexts.size())
     1113                    applyCallToStackVarMap(cblock, routineMap, stackVarMap,
     1114                                    pfStartIndex-1, -1);
    10981115            }
    10991116        }
     
    11051122        const CodeBlock& cblock = codeBlocks[entry.blockIndex];
    11061123        for (const auto& sentry: cblock.ssaInfoMap)
    1107             stackVarMap[sentry.first] = pfit - prevFlowStack.begin();
     1124            stackVarMap[sentry.first] = { size_t(pfit - prevFlowStack.begin()), false };
     1125       
     1126        if (entry.nextIndex > cblock.nexts.size())
     1127            applyCallToStackVarMap(cblock, routineMap, stackVarMap,
     1128                        pfit - prevFlowStack.begin(), entry.nextIndex);
    11081129       
    11091130        // put to first point cache
     
    11581179                        {
    11591180                            auto it = stackVarMap.find(sentry.first);
    1160                             const size_t pfStart = (it != stackVarMap.end() ?
    1161                                         it->second : 0);
     1181                            LastVRegStackPos stackPos = (it != stackVarMap.end() ?
     1182                                        it->second : LastVRegStackPos{ 0, false });
    11621183                           
    1163                             joinVRegRecur(prevFlowStack, codeBlocks, routineMap,
    1164                                 LastVRegStackPos{ pfStart, false }, sentry.first,
    1165                                 sentry.second.ssaIdBefore, vregIndexMaps,
     1184                            joinVRegRecur(prevFlowStack, codeBlocks, routineMap, stackPos,
     1185                                sentry.first, sentry.second.ssaIdBefore, vregIndexMaps,
    11661186                                livenesses, regTypesNum, regRanges, true);
    11671187                        }
     
    11821202                           
    11831203                            auto it = stackVarMap.find(rsentry.first);
    1184                             const size_t pfStart = (it != stackVarMap.end() ?
    1185                                         it->second : 0);
     1204                            LastVRegStackPos stackPos = (it != stackVarMap.end() ?
     1205                                        it->second : LastVRegStackPos{ 0, false });
    11861206                           
    1187                             joinVRegRecur(prevFlowStack, codeBlocks, routineMap,
    1188                                 LastVRegStackPos{ pfStart, false }, rsentry.first,
    1189                                 rsentry.second, vregIndexMaps,
     1207                            joinVRegRecur(prevFlowStack, codeBlocks, routineMap, stackPos,
     1208                                rsentry.first, rsentry.second, vregIndexMaps,
    11901209                                livenesses, regTypesNum, regRanges, true);
    11911210                        }
     
    12181237        {
    12191238            // add toResolveMap ssaIds inside called routines
    1220             /*for (const auto& next: cblock.nexts)
     1239            for (const auto& next: cblock.nexts)
    12211240                if (next.isCall)
    12221241                {
    1223                     const RoutineData& rdata = routineMap.find(next.block)->second;
     1242                    const RoutineDataLv& rdata = routineMap.find(next.block)->second;
    12241243                    for (const auto& v: rdata.rbwSSAIdMap)
    12251244                        alreadyReadMap.insert({v.first, entry.blockIndex });
    1226                     for (const auto& v: rdata.lastSSAIdMap)
     1245                    for (const auto& v: rdata.lastAccessMap)
    12271246                        alreadyReadMap.insert({v.first, entry.blockIndex });
    1228                 }*/
     1247                }
    12291248           
    12301249            flowStack.push_back({ entry.blockIndex+1, 0 });
     
    12351254            // remove old to resolve in leaved way to allow collecting next ssaId
    12361255            // before write (can be different due to earlier visit)
    1237             /*for (const auto& next: cblock.nexts)
     1256            for (const auto& next: cblock.nexts)
    12381257                if (next.isCall)
    12391258                {
    1240                     const RoutineData& rdata = routineMap.find(next.block)->second;
     1259                    const RoutineDataLv& rdata = routineMap.find(next.block)->second;
    12411260                    for (const auto& v: rdata.rbwSSAIdMap)
    12421261                    {
     
    12451264                            alreadyReadMap.erase(it);
    12461265                    }
    1247                     for (const auto& v: rdata.lastSSAIdMap)
     1266                    for (const auto& v: rdata.lastAccessMap)
    12481267                    {
    12491268                        auto it = alreadyReadMap.find(v.first);
     
    12511270                            alreadyReadMap.erase(it);
    12521271                    }
    1253                 }*/
     1272                }
    12541273           
    12551274            for (const auto& sentry: cblock.ssaInfoMap)
     
    12661285                !joinSecondPointsCache.hasKey(entry.blockIndex))
    12671286                // add to cache
    1268                 addJoinSecCacheEntry(codeBlocks, joinSecondPointsCache,
     1287                addJoinSecCacheEntry(routineMap, codeBlocks, joinSecondPointsCache,
    12691288                            entry.blockIndex);
    12701289           
     
    18471866    // after, that resolve joins (join with already visited code)
    18481867    // SVRegMap in this cache: key - vreg, value - last flowStack entry position
    1849     SimpleCache<size_t, SVRegMap> joinFirstPointsCache(wrCount<<1);
     1868    SimpleCache<size_t, LastStackPosMap> joinFirstPointsCache(wrCount<<1);
    18501869    // SVRegMap in this cache: key - vreg, value - first readBefore in second part
    18511870    SimpleCache<size_t, SVRegMap> joinSecondPointsCache(rbwCount<<1);
     
    18961915                !joinSecondPointsCache.hasKey(entry.blockIndex))
    18971916                // add to cache
    1898                 addJoinSecCacheEntry(codeBlocks, joinSecondPointsCache,
     1917                addJoinSecCacheEntry(routineMap, codeBlocks, joinSecondPointsCache,
    18991918                            entry.blockIndex);
    19001919            flowStack.pop_back();
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.h

    r4104 r4106  
    212212typedef std::unordered_map<AsmSingleVReg, VectorSet<LastAccessBlockPos> > LastAccessMap;
    213213typedef std::unordered_map<AsmSingleVReg, LastAccessBlockPos> RoutineCurAccessMap;
     214class CLRX_INTERNAL LastStackPosMap
     215        : public std::unordered_map<AsmSingleVReg, LastVRegStackPos>
     216{
     217public:
     218    LastStackPosMap()
     219    { }
     220   
     221    size_t weight() const
     222    { return size(); }
     223};
    214224
    215225// Routine data for createLivenesses - holds svreg read before writes and
Note: See TracChangeset for help on using the changeset viewer.