Changeset 3848 in CLRX


Ignore:
Timestamp:
Feb 24, 2018, 12:56:02 PM (14 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Stuff with second cache (doesn't work).

File:
1 edited

Legend:

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

    r3847 r3848  
    521521    }
    522522   
     523    bool hasKey(const K& key)
     524    { return entryMap.find(key) != entryMap.end(); }
     525   
    523526    // put value
    524527    void put(const K& key, const V& value)
     
    674677}
    675678
    676 static void resolveSSAConflicts(const std::deque<FlowStackEntry>& prevFlowStack,
     679typedef std::unordered_map<size_t, std::pair<size_t, size_t> > PrevWaysIndexMap;
     680
     681static void resolveSSAConflicts(const std::deque<FlowStackEntry2>& prevFlowStack,
    677682        const std::unordered_map<size_t, RoutineData>& routineMap,
    678683        const std::vector<CodeBlock>& codeBlocks,
    679         std::vector<bool>& cblocksToCache,
     684        const PrevWaysIndexMap& prevWaysIndexMap,
     685        const std::vector<bool>& waysToCache, std::vector<bool>& cblocksToCache,
     686        SimpleCache<size_t, LastSSAIdMap>& resFirstPointsCache,
    680687        SimpleCache<size_t, RBWSSAIdMap>& resSecondPointsCache,
    681688        SSAReplacesMap& replacesMap)
     
    686693    std::cout << "startResolv: " << (pfEnd-1)->blockIndex << "," << nextBlock << std::endl;
    687694    LastSSAIdMap stackVarMap;
    688     for (auto pfit = prevFlowStack.begin(); pfit != pfEnd; ++pfit)
    689     {
    690         const FlowStackEntry& entry = *pfit;
     695   
     696    size_t pfStartIndex = 0;
     697    /*{
     698        auto pfPrev = --pfEnd;
     699        auto it = prevWaysIndexMap.find(pfPrev->blockIndex);
     700        if (it != prevWaysIndexMap.end())
     701        {
     702            const LastSSAIdMap* cached = resFirstPointsCache.use(pfPrev->blockIndex);
     703            if (cached!=nullptr)
     704            {
     705                stackVarMap = *cached;
     706                pfStartIndex = it->second.second+1;
     707            }
     708        }
     709    }*/
     710   
     711    for (auto pfit = prevFlowStack.begin()+pfStartIndex; pfit != pfEnd; ++pfit)
     712    {
     713        const FlowStackEntry2& entry = *pfit;
    691714        std::cout << "  apply: " << entry.blockIndex << std::endl;
    692715        const CodeBlock& cblock = codeBlocks[entry.blockIndex];
     
    708731                        stackVarMap[sentry.first] = sentry.second;
    709732                }
     733       
     734        // put to first point cache
     735        if (waysToCache[pfit->blockIndex] && !resFirstPointsCache.hasKey(pfit->blockIndex))
     736            resFirstPointsCache.put(pfit->blockIndex, stackVarMap);
    710737    }
    711738   
     
    11381165    assembler.isaAssembler->getRegisterRanges(regTypesNum, regRanges);
    11391166   
    1140     size_t rbwCount = 0;
    1141    
    11421167    while (true)
    11431168    {
     
    11791204                    sinfo.ssaIdBefore = sinfo.ssaIdFirst =
    11801205                            sinfo.ssaId = sinfo.ssaIdLast = 0;
    1181                 // count read before writes (for cache weight)
    1182                 if (rvu.regVar!=nullptr && sinfo.readBeforeWrite)
    1183                     rbwCount++;
    11841206            }
    11851207            // get next rvusage
     
    11901212        ++cbit;
    11911213    }
     1214   
     1215    size_t rbwCount = 0;
     1216    size_t wrCount = 0;
    11921217   
    11931218    std::deque<CallStackEntry> callStack;
     
    12011226    // routine map - routine datas map, value - last SSA ids map
    12021227    std::unordered_map<size_t, RoutineData> routineMap;
    1203    
     1228    // key - current res first key, value - previous first key and its flowStack pos
     1229    PrevWaysIndexMap prevWaysIndexMap;
     1230    // to track ways last block indices pair: block index, flowStackPos)
     1231    std::stack<std::pair<size_t, size_t> > cacheWaysStack;
     1232   
     1233    std::vector<bool> waysToCache(codeBlocks.size(), false);
    12041234    std::vector<bool> cblocksToCache(codeBlocks.size(), false);
    12051235    std::vector<bool> visited(codeBlocks.size(), false);
     
    12581288                        updateRoutineData(routineMap.find(
    12591289                            callStack.back().routineBlock)->second, ssaEntry);
     1290                       
     1291                    // count read before writes (for cache weight)
     1292                    if (sinfo.readBeforeWrite)
     1293                        rbwCount++;
     1294                    if (sinfo.ssaIdChange!=0)
     1295                        wrCount++;
    12601296                }
    12611297            }
     
    12651301                // back, already visited
    12661302                flowStack.pop_back();
     1303               
     1304                // track cache points in way (res first points)
     1305                size_t curWayBIndex = flowStack.back().blockIndex;
     1306                waysToCache[curWayBIndex] = true;
     1307                size_t prevWayBIndex = SIZE_MAX;
     1308                if (!cacheWaysStack.empty())
     1309                {
     1310                    std::pair<size_t, size_t> prevWayEntry = cacheWaysStack.top();
     1311                    prevWayBIndex = prevWayEntry.first;
     1312                    if (prevWayBIndex != curWayBIndex)
     1313                        prevWaysIndexMap[curWayBIndex] = prevWayEntry;
     1314                }
     1315                if (prevWayBIndex != curWayBIndex)
     1316                    cacheWaysStack.push(std::make_pair(curWayBIndex, flowStack.size()-1));
    12671317                continue;
    12681318            }
     
    13511401                if (rdata!=nullptr)
    13521402                    updateRoutineCurSSAIdMap(rdata, ssaEntry, entry, curSSAId, nextSSAId);
    1353                 {
    1354                    
    1355                 }
    13561403            }
    13571404           
    13581405            std::cout << "pop: " << entry.blockIndex << std::endl;
     1406            if (!cacheWaysStack.empty() && cacheWaysStack.top().first == entry.blockIndex)
     1407                cacheWaysStack.pop();
    13591408            flowStack.pop_back();
    13601409        }
     
    13651414     **********/
    13661415    flowStack.clear();
     1416    std::deque<FlowStackEntry2> flowStack2;
     1417   
    13671418    std::fill(visited.begin(), visited.end(), false);
    1368     flowStack.push_back({ 0, 0 });
    1369    
     1419    flowStack2.push_back({ 0, 0 });
     1420   
     1421    SimpleCache<size_t, LastSSAIdMap> resFirstPointsCache(wrCount<<1);
    13701422    SimpleCache<size_t, RBWSSAIdMap> resSecondPointsCache(rbwCount<<1);
    13711423   
    1372     while (!flowStack.empty())
    1373     {
    1374         FlowStackEntry& entry = flowStack.back();
     1424    while (!flowStack2.empty())
     1425    {
     1426        FlowStackEntry2& entry = flowStack2.back();
    13751427        CodeBlock& cblock = codeBlocks[entry.blockIndex];
    13761428       
     
    13821434            else
    13831435            {
    1384                 resolveSSAConflicts(flowStack, routineMap, codeBlocks, cblocksToCache,
    1385                             resSecondPointsCache, ssaReplacesMap);
     1436                resolveSSAConflicts(flowStack2, routineMap, codeBlocks,
     1437                            prevWaysIndexMap, waysToCache, cblocksToCache,
     1438                            resFirstPointsCache, resSecondPointsCache, ssaReplacesMap);
    13861439               
    13871440                // join routine data
     
    13921445                            callStack.back().routineBlock)->second, rit->second);*/
    13931446                /*if (!callStack.empty())
    1394                     collectSSAIdsForCall(flowStack, callStack, visited,
     1447                    collectSSAIdsForCall(flowStack2, callStack, visited,
    13951448                            routineMap, codeBlocks);*/
    13961449                // back, already visited
    1397                 flowStack.pop_back();
     1450                flowStack2.pop_back();
    13981451                continue;
    13991452            }
     
    14021455        if (entry.nextIndex < cblock.nexts.size())
    14031456        {
    1404             flowStack.push_back({ cblock.nexts[entry.nextIndex].block, 0 });
     1457            flowStack2.push_back({ cblock.nexts[entry.nextIndex].block, 0 });
    14051458            entry.nextIndex++;
    14061459        }
     
    14101463                 !cblock.haveReturn && !cblock.haveEnd)
    14111464        {
    1412             flowStack.push_back({ entry.blockIndex+1, 0 });
     1465            flowStack2.push_back({ entry.blockIndex+1, 0 });
    14131466            entry.nextIndex++;
    14141467        }
    14151468        else // back
    1416             flowStack.pop_back();
     1469            flowStack2.pop_back();
    14171470    }
    14181471}
Note: See TracChangeset for help on using the changeset viewer.