Changeset 3953 in CLRX


Ignore:
Timestamp:
Mar 31, 2018, 1:09:58 PM (6 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmRegAlloc?: Beginning the rewriting of the recursion support.

File:
1 edited

Legend:

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

    r3951 r3953  
    15711571}
    15721572
    1573 static inline const RoutineData* findRoutine(
    1574         const std::unordered_map<size_t, RoutineData>& routineMap,
    1575         const std::unordered_map<size_t, RoutineData>* routineMapRecur, size_t block)
    1576 {
    1577     if (routineMapRecur != nullptr)
    1578     {
    1579         auto rit = routineMapRecur->find(block);
    1580         if (rit != routineMapRecur->end())
    1581             return &rit->second;
    1582     }
    1583     auto rit = routineMap.find(block);
    1584     return rit!=routineMap.end() ? &rit->second : nullptr;
    1585 }
    1586 
    1587 struct CLRX_INTERNAL RetRecurState
    1588 {
    1589     std::unordered_map<AsmSingleVReg, size_t> curSSAIdMap;
    1590     RetSSAIdMap retSSAIdMap;
    1591     std::deque<FlowStackEntry> flowStack;
    1592     std::vector<bool> flowStackBlocks;
    1593     std::deque<CallStackEntry> callStack;
    1594 };
    1595 
    1596 typedef std::unordered_map<size_t, RetRecurState> RetRecurStateMap;
    1597 
    1598 typedef std::unordered_map<size_t, std::unordered_map<size_t, RetRecurState> >
    1599             RetRecurStateMapMap;
    16001573
    16011574static void createRoutineData(const std::vector<CodeBlock>& codeBlocks,
    1602         SSAReplacesMap& ssaReplacesMap,
    16031575        std::unordered_map<AsmSingleVReg, size_t>& curSSAIdMap,
    16041576        const std::unordered_set<size_t>& loopBlocks,
    1605         const std::unordered_set<size_t>& recurBlocks,
    16061577        const ResSecondPointsToCache& subroutToCache,
    16071578        SimpleCache<size_t, RoutineData>& subroutinesCache,
    1608         const std::unordered_map<size_t, RoutineData>& routineMap,
    1609         const std::unordered_map<size_t, RoutineData>* routineMapRecur,
    1610         RetRecurStateMapMap& retRecurStateMapMap,
    1611         RoutineData& rdata, size_t routineBlock, bool noMainLoop = false,
    1612         const std::vector<bool>& prevFlowStackBlocks = {},
    1613         const std::deque<CallStackEntry>& callStack = {},
    1614         RetRecurState* retRecurState = nullptr)
     1579        const std::unordered_map<size_t, RoutineData>& routineMap, RoutineData& rdata,
     1580        size_t routineBlock, bool noMainLoop = false,
     1581        const std::vector<bool>& prevFlowStackBlocks = {})
    16151582{
    16161583    std::cout << "--------- createRoutineData ----------------\n";
     
    16251592    if (!prevFlowStackBlocks.empty())
    16261593        flowStackBlocks = prevFlowStackBlocks;
    1627    
    1628     // SSAId for join recursion returns
    1629     RoutineData retRecurRdata;
    16301594    // last SSA ids map from returns
    16311595    RetSSAIdMap retSSAIdMap;
    16321596    flowStack.push_back({ routineBlock, 0 });
    16331597    flowStackBlocks[routineBlock] = true;
    1634    
    1635     bool returnFromRecur = (retRecurState != nullptr);
    1636     if (retRecurState != nullptr)
    1637     {
    1638         std::cout << " -- -- get retrecurstate" << std::endl;
    1639         retSSAIdMap = retRecurState->retSSAIdMap;
    1640         flowStack = retRecurState->flowStack;
    1641         flowStackBlocks = retRecurState->flowStackBlocks;
    1642     }
    16431598   
    16441599    while (!flowStack.empty())
     
    16591614                {
    16601615                    RoutineData* subRdata = subroutinesCache.use(entry.blockIndex);
    1661                     if (returnFromRecur)
    1662                         joinLastSSAIdMap(retRecurRdata.lastSSAIdMap,
    1663                                     loopsit2->second.ssaIdMap, *subRdata, true);
    1664                    
    16651616                    joinLastSSAIdMap(rdata.lastSSAIdMap, loopsit2->second.ssaIdMap,
    16661617                                        *subRdata, true);
     
    16721623            const bool oldFB = flowStackBlocks[entry.blockIndex];
    16731624            flowStackBlocks[entry.blockIndex] = !oldFB;
    1674             createRoutineData(codeBlocks, ssaReplacesMap, curSSAIdMap, loopBlocks,
    1675                     recurBlocks, subroutToCache, subroutinesCache, routineMap,
    1676                     routineMapRecur, retRecurStateMapMap, subrData, entry.blockIndex,
    1677                     true, flowStackBlocks);
     1625            createRoutineData(codeBlocks, curSSAIdMap, loopBlocks, subroutToCache,
     1626                subroutinesCache, routineMap, subrData, entry.blockIndex, true,
     1627                flowStackBlocks);
    16781628            RoutineData subrDataCopy;
    16791629            flowStackBlocks[entry.blockIndex] = oldFB;
     
    16921642                    std::cout << "   loopssaIdMap2End: " << std::endl;
    16931643                    if (applyToMainRoutine)
    1694                     {
    1695                         if (returnFromRecur)
    1696                             joinLastSSAIdMap(retRecurRdata.lastSSAIdMap,
    1697                                     loopsit2->second.ssaIdMap, subrDataCopy, true);
    16981644                        joinLastSSAIdMap(rdata.lastSSAIdMap, loopsit2->second.ssaIdMap,
    16991645                                        subrDataCopy, true);
    1700                     }
    17011646                }
    17021647            }
     
    17721717                {
    17731718                    // try in routine map
    1774                     /*rit = routineMap.find(entry.blockIndex);
     1719                    auto rit = routineMap.find(entry.blockIndex);
    17751720                    if (rit != routineMap.end())
    1776                         cachedRdata = &rit->second;*/
    1777                     cachedRdata = findRoutine(routineMap, routineMapRecur,
    1778                                 entry.blockIndex);
     1721                        cachedRdata = &rit->second;
    17791722                }
    17801723                if (!isLoop && visited[entry.blockIndex] && cachedRdata == nullptr &&
     
    17921735                std::cout << "use cached subr " << entry.blockIndex << std::endl;
    17931736                std::cout << "procret2: " << entry.blockIndex << std::endl;
    1794                 if (returnFromRecur)
    1795                     joinLastSSAIdMap(retRecurRdata.lastSSAIdMap,
    1796                             retRecurRdata.curSSAIdMap, *cachedRdata);
    1797                
    17981737                joinLastSSAIdMap(rdata.lastSSAIdMap, rdata.curSSAIdMap, *cachedRdata);
    17991738                // get not given rdata curSSAIdMap ssaIds but present in cachedRdata
    18001739                // curSSAIdMap
    18011740                for (const auto& entry: cachedRdata->curSSAIdMap)
    1802                 {
    18031741                    if (rdata.curSSAIdMap.find(entry.first) == rdata.curSSAIdMap.end())
    18041742                    {
    18051743                        auto cit = curSSAIdMap.find(entry.first);
    18061744                        size_t prevSSAId = (cit!=curSSAIdMap.end() ? cit->second : 1)-1;
    1807                        
    18081745                        rdata.curSSAIdMap.insert({ entry.first, { prevSSAId } });
    18091746                       
     
    18161753                        }
    18171754                    }
    1818                     if (returnFromRecur && retRecurRdata.curSSAIdMap.find(entry.first) ==
    1819                                 retRecurRdata.curSSAIdMap.end())
    1820                     {
    1821                         auto cit = curSSAIdMap.find(entry.first);
    1822                         size_t prevSSAId = (cit!=curSSAIdMap.end() ? cit->second : 1)-1;
    1823                        
    1824                         retRecurRdata.curSSAIdMap.insert(
    1825                                     { entry.first, { prevSSAId } });
    1826                         retRecurRdata.lastSSAIdMap.insertSSAId(entry.first, prevSSAId);
    1827                     }
    1828                 }
    18291755               
    18301756                // join loopEnds
     
    18631789                    if (ssaEntry.first.regVar != nullptr)
    18641790                    {
    1865                         if (returnFromRecur)
    1866                             updateRoutineData(retRecurRdata, ssaEntry,
    1867                                         curSSAIdMap[ssaEntry.first]-1);
    1868                        
    18691791                        // put data to routine data
    18701792                        updateRoutineData(rdata, ssaEntry, curSSAIdMap[ssaEntry.first]-1);
     
    18861808        for (; entry.nextIndex < cblock.nexts.size() &&
    18871809                    cblock.nexts[entry.nextIndex].isCall; entry.nextIndex++)
    1888         {
    1889             const size_t nextRBlock = cblock.nexts[entry.nextIndex].block;
    1890             if (recurBlocks.find(nextRBlock) != recurBlocks.end())
    1891             {
    1892                 std::cout << "-- crd recurBlock store ppoint: " << nextRBlock
    1893                         << std::endl;
    1894                 continue;
    1895             }
    1896            
    1897             //joinRoutineData(rdata, routineMap.find(
    1898             //                cblock.nexts[entry.nextIndex].block)->second);
    1899             if (recurBlocks.find(nextRBlock) == recurBlocks.end())
    1900             {
    1901                 if (returnFromRecur)
    1902                     joinRoutineData(retRecurRdata, *findRoutine(routineMap,
    1903                                     routineMapRecur, nextRBlock));
    1904                 joinRoutineData(rdata,
    1905                         *findRoutine(routineMap, routineMapRecur, nextRBlock));
    1906             }
    1907         }
     1810            joinRoutineData(rdata, routineMap.find(
     1811                            cblock.nexts[entry.nextIndex].block)->second);
    19081812       
    19091813        if (entry.nextIndex < cblock.nexts.size())
     
    19261830                    {
    19271831                        //std::cout << "joincall:"<< next.block << std::endl;
    1928                         const RoutineData* callRdata = findRoutine(routineMap,
    1929                                 routineMapRecur, next.block); // must find
     1832                        auto it = routineMap.find(next.block); // must find
    19301833                        initializePrevRetSSAIds(cblock, curSSAIdMap, retSSAIdMap,
    1931                                     *callRdata, entry);
    1932                        
    1933                         if (recurBlocks.find(next.block) == recurBlocks.end())
    1934                             joinRetSSAIdMap(retSSAIdMap, callRdata->lastSSAIdMap,
    1935                                             next.block);
    1936                         else if (routineMapRecur != nullptr)
    1937                         {   // put retRecurState
    1938                             std::cout << "-- store retrecurstate: " <<
    1939                                     next.block << ": " << entry.blockIndex << std::endl;
    1940                             std::deque<FlowStackEntry> newFlowStack;
    1941                             newFlowStack.push_back({entry.blockIndex, 0});
    1942                             retRecurStateMapMap[next.block].insert({ entry.blockIndex, {
    1943                                     curSSAIdMap, retSSAIdMap,
    1944                                     newFlowStack, flowStackBlocks, callStack } });
    1945                         }
     1834                                    it->second, entry);
     1835                        joinRetSSAIdMap(retSSAIdMap, it->second.lastSSAIdMap, next.block);
    19461836                    }
    19471837            }
     
    19581848            {
    19591849                std::cout << "procret: " << entry.blockIndex << std::endl;
    1960                 if (returnFromRecur)
    1961                     joinLastSSAIdMap(retRecurRdata.lastSSAIdMap, retRecurRdata.curSSAIdMap);
    19621850                joinLastSSAIdMap(rdata.lastSSAIdMap, rdata.curSSAIdMap);
    19631851                std::cout << "procretend" << std::endl;
    19641852                rdata.notFirstReturn = true;
    1965                 if (returnFromRecur)
    1966                     retRecurRdata.notFirstReturn = true;
    19671853            }
    19681854           
    19691855            // revert retSSAIdMap
    1970             if (returnFromRecur)
    1971                 revertRetSSAIdMap(curSSAIdMap, retSSAIdMap, entry, &retRecurRdata);
    1972            
    19731856            revertRetSSAIdMap(curSSAIdMap, retSSAIdMap, entry, &rdata);
    19741857            //
     
    19871870                            nextSSAId << ", " << curSSAId << std::endl;
    19881871               
    1989                 if (returnFromRecur)
    1990                     updateRoutineCurSSAIdMap(&retRecurRdata, ssaEntry, entry,
    1991                                     curSSAId, nextSSAId);
    19921872                updateRoutineCurSSAIdMap(&rdata, ssaEntry, entry, curSSAId, nextSSAId);
    19931873            }
     
    20111891           
    20121892            if ((!noMainLoop || flowStack.size() > 1) &&
    2013                 subroutToCache.count(entry.blockIndex)!=0 &&
    2014                 recurBlocks.find(entry.blockIndex) == recurBlocks.end() &&
    2015                 retRecurState == nullptr)
    2016             {   //put to cache
     1893                subroutToCache.count(entry.blockIndex)!=0)
     1894            { //put to cache
    20171895                std::cout << "-- subrcache for " << entry.blockIndex << std::endl;
    20181896                addSubroutine(loopsit2, true);
     
    20241902        }
    20251903    }
    2026    
    2027     if (returnFromRecur)
    2028     {
    2029         for (const auto& entry: retRecurRdata.rbwSSAIdMap)
    2030         {
    2031             auto lit = retRecurRdata.lastSSAIdMap.find(entry.first);
    2032             if (lit != retRecurRdata.lastSSAIdMap.end())
    2033                 for (size_t ssaId: lit->second)
    2034                 {
    2035                     if (entry.second < ssaId)
    2036                         insertReplace(ssaReplacesMap, entry.first, ssaId, entry.second);
    2037                     else if (entry.second > ssaId)
    2038                         insertReplace(ssaReplacesMap, entry.first, entry.second, ssaId);
    2039                 }
    2040         }
    2041     }
    20421904    std::cout << "--------- createRoutineData end ------------\n";
    20431905}
    20441906
    2045 
    2046 static void passSecondRecurPass(const std::vector<CodeBlock>& codeBlocks,
    2047             std::unordered_map<AsmSingleVReg, size_t>& curSSAIdMap,
    2048             const ResSecondPointsToCache& cblocksToCache,
    2049             const std::unordered_set<size_t>& loopBlocks,
    2050             const std::unordered_set<size_t>& recurseBlocks,
    2051             std::unordered_map<size_t, RoutineData>& routineMap,
    2052             RetSSAIdMap& retSSAIdMap, SSAReplacesMap& ssaReplacesMap,
    2053             RetRecurStateMapMap& retRecurStateMapMap,
    2054             size_t recurBlock, RoutineData& rdataSP)
    2055 {
    2056     std::cout << "----- passSecondRecurPass: " << recurBlock << std::endl;
    2057     SimpleCache<size_t, RoutineData> subroutinesCache(codeBlocks.size()<<3);
    2058    
    2059     // routineMapSP - routine Map for second of the recursion
    2060     std::unordered_map<size_t, RoutineData> routineMapSP;
    2061     std::vector<bool> isRoutineGen(codeBlocks.size(), false);
    2062     std::deque<CallStackEntry> callStack;
    2063     std::deque<FlowStackEntry> flowStack;
    2064     std::vector<bool> visited(codeBlocks.size(), false);
    2065     flowStack.push_back({ recurBlock, 0 });
    2066    
    2067     callStack.push_back({ SIZE_MAX, 0, recurBlock });
    2068     routineMapSP.insert({ recurBlock, { } });
    2069    
    2070     while (!flowStack.empty())
    2071     {
    2072         FlowStackEntry& entry = flowStack.back();
    2073         const CodeBlock& cblock = codeBlocks[entry.blockIndex];
    2074        
    2075         if (entry.nextIndex == 0)
    2076         {
    2077             // process current block
    2078             if (!visited[entry.blockIndex])
    2079             {
    2080                 std::cout << "proc: " << entry.blockIndex << std::endl;
    2081                 visited[entry.blockIndex] = true;
    2082                
    2083                 for (const auto& ssaEntry: cblock.ssaInfoMap)
    2084                     if (ssaEntry.first.regVar != nullptr && ssaEntry.second.ssaIdChange!=0)
    2085                         curSSAIdMap[ssaEntry.first] = ssaEntry.second.ssaIdLast+1;
    2086             }
    2087             else
    2088             {
    2089                 flowStack.pop_back();
    2090                 continue;
    2091             }
    2092         }
    2093        
    2094         if (!callStack.empty() &&
    2095             entry.blockIndex == callStack.back().callBlock &&
    2096             entry.nextIndex-1 == callStack.back().callNextIndex)
    2097         {
    2098             std::cout << " ret: " << entry.blockIndex << std::endl;
    2099             const size_t routineBlock = callStack.back().routineBlock;
    2100             RoutineData& prevRdata = routineMapSP.find(routineBlock)->second;
    2101             if (!isRoutineGen[routineBlock])
    2102             {
    2103                 createRoutineData(codeBlocks, ssaReplacesMap, curSSAIdMap,
    2104                         loopBlocks, recurseBlocks,
    2105                         cblocksToCache, subroutinesCache, routineMap, &routineMapSP,
    2106                         retRecurStateMapMap, prevRdata, routineBlock,
    2107                         false, {}, callStack);
    2108                 //prevRdata.compare(myRoutineData);
    2109                 isRoutineGen[routineBlock] = true;
    2110             }
    2111            
    2112             callStack.pop_back(); // just return from call
    2113             //callBlocks.erase(routineBlock);
    2114         }
    2115        
    2116         if (entry.nextIndex < cblock.nexts.size())
    2117         {
    2118             const size_t nextBlock = cblock.nexts[entry.nextIndex].block;
    2119             if (cblock.nexts[entry.nextIndex].isCall)
    2120             {
    2121                 std::cout << " call: " << entry.blockIndex << std::endl;
    2122                 if (recurseBlocks.find(nextBlock) == recurseBlocks.end())
    2123                 {
    2124                     // no recursion - normal call
    2125                     callStack.push_back({ entry.blockIndex, entry.nextIndex, nextBlock });
    2126                     routineMapSP.insert({ nextBlock, { } });
    2127                 }
    2128                 else
    2129                     std::cout << "   -- recursion: " << nextBlock << std::endl;
    2130             }
    2131             entry.nextIndex++;
    2132         }
    2133         else if (((entry.nextIndex==0 && cblock.nexts.empty()) ||
    2134                 // if have any call then go to next block
    2135                 (cblock.haveCalls && entry.nextIndex==cblock.nexts.size())) &&
    2136                  !cblock.haveReturn && !cblock.haveEnd)
    2137         {
    2138             if (entry.nextIndex!=0) // if back from calls (just return from calls)
    2139             {
    2140                 reduceSSAIdsForCalls(entry, codeBlocks, retSSAIdMap, routineMapSP,
    2141                                      ssaReplacesMap);
    2142                 //
    2143                 for (const NextBlock& next: cblock.nexts)
    2144                     if (next.isCall)
    2145                     {
    2146                         //std::cout << "joincall:"<< next.block << std::endl;
    2147                         auto it = routineMap.find(next.block); // must find
    2148                         initializePrevRetSSAIds(cblock, curSSAIdMap, retSSAIdMap,
    2149                                     it->second, entry);
    2150                         joinRetSSAIdMap(retSSAIdMap, it->second.lastSSAIdMap, next.block);
    2151                     }
    2152             }
    2153             entry.nextIndex++;
    2154         }
    2155         else
    2156         {
    2157             RoutineData* rdata = nullptr;
    2158             if (!callStack.empty())
    2159                 rdata = &(routineMapSP.find(callStack.back().routineBlock)->second);
    2160            
    2161             // revert retSSAIdMap
    2162             revertRetSSAIdMap(curSSAIdMap, retSSAIdMap, entry, rdata);
    2163             //
    2164            
    2165             for (const auto& ssaEntry: cblock.ssaInfoMap)
    2166             {
    2167                 if (ssaEntry.first.regVar == nullptr)
    2168                     continue;
    2169                
    2170                 size_t& curSSAId = curSSAIdMap[ssaEntry.first];
    2171                 const size_t nextSSAId = curSSAId;
    2172                 curSSAId = ssaEntry.second.ssaIdBefore+1;
    2173                
    2174                 std::cout << "popcurnext: " << ssaEntry.first.regVar <<
    2175                             ":" << ssaEntry.first.index << ": " <<
    2176                             nextSSAId << ", " << curSSAId << std::endl;
    2177             }
    2178            
    2179             std::cout << "pop: " << entry.blockIndex << std::endl;
    2180             //flowStackBlocks[entry.blockIndex] = false;
    2181             flowStack.pop_back();
    2182         }
    2183     }
    2184     std::cout << "----- passSecondRecurPass end: " << recurBlock << std::endl;
    2185    
    2186     rdataSP = routineMapSP.find(recurBlock)->second;
    2187     createRoutineData(codeBlocks, ssaReplacesMap, curSSAIdMap, loopBlocks,
    2188                 recurseBlocks, cblocksToCache, subroutinesCache, routineMap,
    2189                 &routineMapSP, retRecurStateMapMap, rdataSP, recurBlock);
    2190    
    2191     // replace routineMap entries by routineMapSP entries
    2192     for (const auto& entry: routineMapSP)
    2193         if (entry.first != recurBlock)
    2194             routineMap[entry.first] = entry.second;
    2195     std::cout << "----- passSecondRecurPass after: " << recurBlock << std::endl;
    2196 }
    2197 
    2198 
    2199 struct CLRX_INTERNAL RecurStateEntry
    2200 {
    2201     std::unordered_map<AsmSingleVReg, size_t> curSSAIdMap;
    2202     RetSSAIdMap retSSAIdMap;
    2203 };
    22041907
    22051908void AsmRegAllocator::createSSAData(ISAUsageHandler& usageHandler)
     
    22961999    flowStack.push_back({ 0, 0 });
    22972000    flowStackBlocks[0] = true;
    2298    
    2299     RetRecurStateMapMap retRecurStateMapMap;
    2300     std::unordered_map<size_t, RecurStateEntry> recurStateMap;
    23012001    std::unordered_set<size_t> callBlocks;
    23022002    std::unordered_set<size_t> loopBlocks;
     
    23892089            const size_t routineBlock = callStack.back().routineBlock;
    23902090            RoutineData& prevRdata = routineMap.find(routineBlock)->second;
    2391             if (recurseBlocks.find(routineBlock) != recurseBlocks.end())
    2392             {
    2393                 std::cout << "store recuState: " << routineBlock << std::endl;
    2394                 recurStateMap.insert({ routineBlock, { curSSAIdMap, retSSAIdMap } });
    2395             }
    2396            
    2397             if (!isRoutineGen[routineBlock] && !flowStackBlocks[routineBlock])
    2398             {
    2399                 createRoutineData(codeBlocks, ssaReplacesMap, curSSAIdMap,
    2400                         loopBlocks, recurseBlocks, cblocksToCache, subroutinesCache,
    2401                         routineMap, nullptr, retRecurStateMapMap, prevRdata, routineBlock);
     2091            if (!isRoutineGen[routineBlock])
     2092            {
     2093                createRoutineData(codeBlocks, curSSAIdMap, loopBlocks,
     2094                            cblocksToCache, subroutinesCache, routineMap, prevRdata,
     2095                            routineBlock);
    24022096                //prevRdata.compare(myRoutineData);
    2403                
    2404                 auto rsit = recurStateMap.find(routineBlock);
    2405                 if (rsit != recurStateMap.end())
    2406                 {
    2407                     // second pass through recursion
    2408                     RoutineData rdataSP;
    2409                     passSecondRecurPass(codeBlocks, rsit->second.curSSAIdMap,
    2410                             cblocksToCache, loopBlocks, recurseBlocks, routineMap,
    2411                             rsit->second.retSSAIdMap, ssaReplacesMap,
    2412                             retRecurStateMapMap, routineBlock, rdataSP);
    2413                     // join retRecurStates
    2414                     for (auto& entry: retRecurStateMapMap[routineBlock])
    2415                     {
    2416                         std::cout << "join retrecState: " << entry.first << std::endl;
    2417                         createRoutineData(codeBlocks, ssaReplacesMap,
    2418                                 entry.second.curSSAIdMap,
    2419                                 loopBlocks, recurseBlocks, cblocksToCache,
    2420                                 subroutinesCache, routineMap, nullptr,
    2421                                 retRecurStateMapMap, rdataSP, routineBlock, false, {},
    2422                                 callStack, &entry.second);
    2423                         joinRoutineData(prevRdata, rdataSP);
    2424                     }
    2425                     recurseBlocks.erase(routineBlock);
    2426                 }
    2427                
    24282097                isRoutineGen[routineBlock] = true;
    24292098            }
     
    24422111                if (!callBlocks.insert(nextBlock).second)
    24432112                {
    2444                     std::cout << "   -- recursion: " << nextBlock << std::endl;
    24452113                    // if already called (then it is recursion)
    24462114                    recurseBlocks.insert(nextBlock);
     2115                    std::cout << "   -- recursion: " << nextBlock << std::endl;
    24472116                }
    24482117               
     
    25282197                std::cout << "POPlastCcwP: " << lastCommonCacheWayPoint.first << std::endl;
    25292198            }
     2199           
    25302200        }
    25312201    }
Note: See TracChangeset for help on using the changeset viewer.