Changeset 3851 in CLRX


Ignore:
Timestamp:
Feb 25, 2018, 4:00:19 PM (17 months ago)
Author:
matszpk
Message:

CLRadeonExtender: Add VectorSet? (a vector with insert/erase the unique element).
AsmRegAlloc?: fix some comments, apply VectorSet? to LastSSAId and RetSSAEntry.
Add dump of the test number (AsmRegAlloc?).

Location:
CLRadeonExtender/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/CLRX/utils/Containers.h

    r3575 r3851  
    2828#include <iterator>
    2929#include <algorithm>
     30#include <vector>
    3031#include <initializer_list>
    3132
     
    282283};
    283284
     285/// VectorSet
     286template<typename T>
     287class VectorSet: public std::vector<T>
     288{
     289public:
     290    /// constructor
     291    VectorSet()
     292    { }
     293   
     294    /// constructor
     295    VectorSet(size_t n) : std::vector<T>(n)
     296    { }
     297   
     298    /// constructor
     299    VectorSet(size_t n, const T& v) : std::vector<T>(n, v)
     300    { }
     301   
     302    /// constructor
     303    VectorSet(std::initializer_list<T> l): std::vector<T>(l)
     304    { }
     305   
     306    /// insert new value if doesn't exists
     307    void insertValue(const T& v)
     308    {
     309        auto fit = std::find(std::vector<T>::begin(), std::vector<T>::end(), v);
     310        if (fit == std::vector<T>::end())
     311            std::vector<T>::push_back(v);
     312    }
     313   
     314    /// erase value if exists
     315    void eraseValue(const T& v)
     316    {
     317        auto fit = std::find(std::vector<T>::begin(), std::vector<T>::end(), v);
     318        if (fit != std::vector<T>::end())
     319            std::vector<T>::erase(fit);
     320    }
     321};
     322
     323
    284324/// binary find helper
    285325/**
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.cpp

    r3850 r3851  
    2525#include <utility>
    2626#include <unordered_set>
     27#include <initializer_list>
    2728#include <map>
    2829#include <set>
     
    560561// map of last SSAId for routine, key - varid, value - last SSA ids
    561562class CLRX_INTERNAL LastSSAIdMap: public
    562             std::unordered_map<AsmSingleVReg, std::vector<size_t> >
     563            std::unordered_map<AsmSingleVReg, VectorSet<size_t> >
    563564{
    564565public:
     
    566567    { }
    567568   
     569    iterator insertSSAId(const AsmSingleVReg& vreg, size_t ssaId)
     570    {
     571        auto res = insert({ vreg, { ssaId } });
     572        if (!res.second)
     573            res.first->second.insertValue(ssaId);
     574        return res.first;
     575    }
     576   
     577    void eraseSSAId(const AsmSingleVReg& vreg, size_t ssaId)
     578    {
     579        auto it = find(vreg);
     580        if (it != end())
     581             it->second.eraseValue(ssaId);
     582    }
     583   
    568584    size_t weight() const
    569585    { return size(); }
     
    575591{
    576592    std::vector<size_t> routines;
    577     std::vector<size_t> ssaIds;
     593    VectorSet<size_t> ssaIds;
    578594};
    579595
     
    635651            auto res = cacheSecPoints->insert({ sentry.first, { sinfo.ssaIdBefore } });
    636652            if (!res.second)
    637             {
    638                 auto sit = std::find(res.first->second.begin(), res.first->second.end(),
    639                         sinfo.ssaIdBefore);
    640                 if (sit == res.first->second.end())
    641                     res.first->second.push_back(sinfo.ssaIdBefore);
    642             }
     653                res.first->second.insertValue(sinfo.ssaIdBefore);
    643654        }
    644655       
     
    859870        else // back
    860871        {
    861             // mark resolved variables as not handled for further processing
     872            // remove old to resolve in leaved way to allow collecting next ssaId
     873            // before write (can be different due to earlier visit)
    862874            for (const auto& next: cblock.nexts)
    863875                if (next.isCall)
     
    868880                        auto it = toResolveMap.find(v.first);
    869881                        if (it != toResolveMap.end() && it->second == entry.blockIndex)
    870                             // remove if not handled yet
    871882                            toResolveMap.erase(it);
    872883                    }
     
    875886                        auto it = toResolveMap.find(v.first);
    876887                        if (it != toResolveMap.end() && it->second == entry.blockIndex)
    877                             // remove if not handled yet
    878888                            toResolveMap.erase(it);
    879889                    }
     
    882892            for (const auto& sentry: cblock.ssaInfoMap)
    883893            {
    884                 // mark resolved variables as not handled for further processing
    885894                auto it = toResolveMap.find(sentry.first);
    886895                if (it != toResolveMap.end() && it->second == entry.blockIndex)
    887                     // remove if not handled yet
     896                    // remove old to resolve in leaved way to allow collecting next ssaId
     897                    // before write (can be different due to earlier visit)
    888898                    toResolveMap.erase(it);
    889899            }
     
    911921        if (res.second)
    912922            continue; // added new
    913         std::vector<size_t>& destEntry = res.first->second.ssaIds;
     923        VectorSet<size_t>& destEntry = res.first->second.ssaIds;
    914924        res.first->second.routines.push_back(routineBlock);
    915925        // add new ways
    916926        for (size_t ssaId: entry.second)
    917         {
    918             auto it = std::find(destEntry.begin(), destEntry.end(), ssaId);
    919             if (it == destEntry.end())
    920                 destEntry.push_back(ssaId);
    921         }
     927            destEntry.insertValue(ssaId);
    922928        std::cout << "    :";
    923929        for (size_t v: destEntry)
     
    939945        if (res.second)
    940946            continue; // added new
    941         std::vector<size_t>& destEntry = res.first->second;
     947        VectorSet<size_t>& destEntry = res.first->second;
    942948        // add new ways
    943949        for (size_t ssaId: entry.second)
    944         {
    945             auto it = std::find(destEntry.begin(), destEntry.end(), ssaId);
    946             if (it == destEntry.end())
    947                 destEntry.push_back(ssaId);
    948         }
     950            destEntry.insertValue(ssaId);
    949951        std::cout << "    :";
    950952        for (size_t v: destEntry)
     
    969971        std::cout << std::endl;
    970972        auto res = dest.curSSAIdMap.insert(entry); // find
    971         std::vector<size_t>& destEntry = res.first->second;
     973        VectorSet<size_t>& destEntry = res.first->second;
    972974        if (!res.second)
    973975        {
    974976            // add new ways
    975977            for (size_t ssaId: entry.second)
    976             {
    977                 auto it = std::find(destEntry.begin(), destEntry.end(), ssaId);
    978                 if (it == destEntry.end())
    979                     destEntry.push_back(ssaId);
    980             }
     978                destEntry.insertValue(ssaId);
    981979        }
    982980        auto rbwit = src.rbwSSAIdMap.find(entry.first);
    983981        if (rbwit != src.rbwSSAIdMap.end())
    984         {
    985             auto deit = std::find(destEntry.begin(), destEntry.end(), rbwit->second);
    986             if (deit != destEntry.end())
    987                 destEntry.erase(deit);
    988         }
     982            destEntry.eraseValue(rbwit->second);
    989983        std::cout << "    :";
    990984        for (size_t v: destEntry)
     
    10251019        for (size_t rblock: ssaIdsIt->second.routines)
    10261020            routineMap.find(rblock)->second.lastSSAIdMap[ssaEntry.first] =
    1027                     std::vector<size_t>({ ssaId-1 });
     1021                            VectorSet<size_t>({ ssaId-1 });
    10281022        // finally remove from container (because obsolete)
    10291023        retSSAIdMap.erase(ssaIdsIt);
     
    10851079        if (rdata!=nullptr)
    10861080        {
    1087             std::vector<size_t>& ssaIds = rdata->curSSAIdMap[v.first];
     1081            VectorSet<size_t>& ssaIds = rdata->curSSAIdMap[v.first];
    10881082            for (size_t ssaId: rfit->second.ssaIds)
    1089             {
    1090                 auto ssaIdsIt = std::find(ssaIds.begin(), ssaIds.end(), ssaId);
    1091                 if (ssaIdsIt != ssaIds.end())
    1092                     ssaIds.erase(ssaIdsIt);
    1093             }
     1083                ssaIds.eraseValue(ssaId);
    10941084        }
    10951085       
     
    11011091        if (rdata!=nullptr)
    11021092        {
    1103             std::vector<size_t>& ssaIds = rdata->curSSAIdMap[v.first];
     1093            VectorSet<size_t>& ssaIds = rdata->curSSAIdMap[v.first];
    11041094            for (size_t ssaId: v.second.ssaIds)
    1105             {
    1106                 auto ssaIdsIt = std::find(ssaIds.begin(), ssaIds.end(), ssaId);
    1107                 if (ssaIdsIt == ssaIds.end())
    1108                     ssaIds.push_back(ssaId);
    1109             }
     1095                ssaIds.insertValue(ssaId);
    11101096            if (v.second.ssaIds.empty())
    11111097                ssaIds.push_back(curSSAIdMap[v.first]-1);
     
    11231109            const FlowStackEntry& entry, size_t curSSAId, size_t nextSSAId)
    11241110{
    1125     std::vector<size_t>& ssaIds = rdata->curSSAIdMap[ssaEntry.first];
     1111    VectorSet<size_t>& ssaIds = rdata->curSSAIdMap[ssaEntry.first];
    11261112    std::cout << " pushentry " << entry.blockIndex << ": " <<
    11271113                ssaEntry.first.regVar << ":" << ssaEntry.first.index << ":";
     
    11431129    /*std::cout << "call back: " << nextSSAId << "," <<
    11441130            (curSSAId) << std::endl;*/
    1145     auto fit = std::find(ssaIds.begin(), ssaIds.end(), curSSAId-1);
    1146     if (fit == ssaIds.end())
    1147         ssaIds.push_back(curSSAId-1);
     1131    ssaIds.insertValue(curSSAId-1);
    11481132   
    11491133    std::cout << " popentry " << entry.blockIndex << ": " <<
  • CLRadeonExtender/trunk/tests/amdasm/AsmRegAlloc.cpp

    r3847 r3851  
    35363536static void testCreateSSAData(cxuint i, const AsmSSADataCase& testCase)
    35373537{
     3538    std::cout << "-----------------------------------------------\n"
     3539    "           Test " << i << "\n"
     3540                "------------------------------------------------\n";
    35383541    std::istringstream input(testCase.input);
    35393542    std::ostringstream errorStream;
Note: See TracChangeset for help on using the changeset viewer.