Changeset 3839 in CLRX


Ignore:
Timestamp:
Feb 23, 2018, 3:17:23 PM (17 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Add SimpleCache? to AsmRegAlloc?. Use SSAInfo shortcut in the code.

File:
1 edited

Legend:

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

    r3838 r3839  
    442442}
    443443
     444/** Simple cache **/
     445
     446template<typename K, typename V>
     447class CLRX_INTERNAL SimpleCache
     448{
     449private:
     450    struct Entry
     451    {
     452        size_t sortedPos;
     453        size_t usage;
     454        V value;
     455    };
     456   
     457    size_t totalWeight;
     458    size_t maxWeight;
     459   
     460    typedef typename std::unordered_map<K, Entry>::iterator EntryMapIt;
     461    // sorted entries - sorted by weight
     462    std::vector<EntryMapIt> sortedEntries;
     463    std::unordered_map<K, Entry> entryMap;
     464   
     465    void updateInSortedEntries(EntryMapIt it)
     466    {
     467        size_t i;
     468        for (i = it->second.sortedPos; i > 0 &&
     469             // sort by usage or if equal by weight in reverse order
     470             (sortedEntries[i-1]->second.usage < it->second.usage ||
     471              (sortedEntries[i-1]->second.usage == it->second.usage &&
     472               sortedEntries[i-1]->second.value.weight() < it->second.value.weight()));
     473              i--)
     474        {
     475            sortedEntries[i-1]->second.sortedPos++;
     476            std::swap(sortedEntries[i-1], sortedEntries[i]);
     477        }
     478        it->second.sortedPos = i;
     479    }
     480   
     481    void insertToSortedEntries(EntryMapIt it)
     482    {
     483        it->second.sortedPos = sortedEntries.size();
     484        sortedEntries.push_back(it);
     485        updateInSortedEntries(it);
     486    }
     487   
     488    void removeFromSortedEntries(size_t pos)
     489    {
     490        // update later element positioning
     491        for (size_t i = pos+1; i < sortedEntries.size(); i++)
     492            (sortedEntries[i]->second.sortedPos)--;
     493        sortedEntries.erase(sortedEntries.begin() + pos);
     494    }
     495   
     496public:
     497    explicit SimpleCache(size_t _maxWeight) : totalWeight(0), maxWeight(_maxWeight)
     498    { }
     499   
     500    // use key - get value
     501    V* use(const K& key)
     502    {
     503        auto it = entryMap.find(key);
     504        if (it != entryMap.end())
     505        {
     506            it->second.usage++;
     507            updateInSortedEntries(it);
     508            return &(it->second.value);
     509        }
     510        return nullptr;
     511    }
     512   
     513    // put value
     514    void put(const K& key, const V& value)
     515    {
     516        auto res = entryMap.insert({ key, Entry{ 0, 0, value } });
     517        if (!res.second)
     518        {
     519            removeFromSortedEntries(res.first->second.sortedPos); // remove old value
     520            // update value
     521            totalWeight -= res.first->second.value.weight();
     522            res.first->second = Entry{ 0, 0, value };
     523        }
     524        const size_t elemWeight = value.weight();
     525       
     526        while (totalWeight+elemWeight > maxWeight)
     527        {
     528            // remove min usage element
     529            auto minUsageIt = sortedEntries.back();
     530            sortedEntries.pop_back();
     531            totalWeight -= minUsageIt->second.value.weight();
     532            entryMap.erase(minUsageIt);
     533        }
     534       
     535        insertToSortedEntries(res.first); // new entry in sorted entries
     536       
     537        totalWeight += elemWeight;
     538        // correct max weight if element have greater weight
     539        maxWeight = std::max(elemWeight, maxWeight);
     540    }
     541};
     542
     543/** Simple cache **/
     544
    444545// map of last SSAId for routine, key - varid, value - last SSA ids
    445546typedef std::unordered_map<AsmSingleVReg, std::vector<size_t> > LastSSAIdMap;
     
    497598            std::unordered_map<AsmSingleVReg, size_t>& toResolveMap,
    498599            FlowStackEntry2& entry,
    499             const std::pair<const AsmSingleVReg, AsmRegAllocator::SSAInfo>& sentry)
     600            const std::pair<const AsmSingleVReg, SSAInfo>& sentry)
    500601{
    501602    const SSAInfo& sinfo = sentry.second;
     
    8991000            RetSSAIdMap& retSSAIdMap, std::unordered_map<size_t, RoutineData>& routineMap,
    9001001            SSAReplacesMap& ssaReplacesMap,
    901             std::pair<const AsmSingleVReg, AsmRegAllocator::SSAInfo>& ssaEntry)
     1002            std::pair<const AsmSingleVReg, SSAInfo>& ssaEntry)
    9021003{
    9031004    SSAInfo& sinfo = ssaEntry.second;
     
    9351036
    9361037static void updateRoutineData(RoutineData& rdata,
    937         std::pair<const AsmSingleVReg, AsmRegAllocator::SSAInfo>& ssaEntry)
     1038        std::pair<const AsmSingleVReg, SSAInfo>& ssaEntry)
    9381039{
    9391040    const SSAInfo& sinfo = ssaEntry.second;
     
    9491050        // put last SSAId
    9501051        //std::cout << "PutC: " << sinfo.ssaIdLast << std::endl;
    951         auto res = rdata.curSSAIdMap.insert({ ssaEntry.first,
    952                 { sinfo.ssaIdLast } });
     1052        auto res = rdata.curSSAIdMap.insert({ ssaEntry.first, { sinfo.ssaIdLast } });
    9531053        if (!res.second)
    9541054        {
     
    10261126
    10271127static void updateRoutineCurSSAIdMap(RoutineData* rdata,
    1028             const std::pair<const AsmSingleVReg, AsmRegAllocator::SSAInfo>& ssaEntry,
     1128            const std::pair<const AsmSingleVReg, SSAInfo>& ssaEntry,
    10291129            const FlowStackEntry& entry, size_t curSSAId, size_t nextSSAId)
    10301130{
     
    11361236    std::unordered_map<size_t, RoutineData> routineMap;
    11371237   
     1238    std::vector<bool> cblocksToCache(codeBlocks.size(), false);
    11381239    std::vector<bool> visited(codeBlocks.size(), false);
    11391240    flowStack.push_back({ 0, 0 });
     
    11951296            else
    11961297            {
     1298                cblocksToCache[entry.blockIndex] = true;
    11971299                // back, already visited
    11981300                flowStack.pop_back();
Note: See TracChangeset for help on using the changeset viewer.