Ignore:
Timestamp:
11/07/06 21:32:10 (18 years ago)
Author:
mattausch
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed
  • GTP/trunk/Lib/Vis/Preprocessing/src/HierarchyManager.cpp

    r1719 r1723  
    7979 
    8080 
     81void HierarchySubdivisionStats::Print(ostream &app) const 
     82{ 
     83        app << "#Pass\n" << 0 << endl 
     84                << "#Splits\n" << mNumSplits << endl  
     85                << "#TotalRenderCost\n" << mTotalRenderCost << endl 
     86                << "#TotalEntriesInPvs\n" << mEntriesInPvs << endl 
     87                << "#Memory\n" << mMemoryCost << endl 
     88                << "#StepsView\n" << mViewSpaceSplits << endl 
     89                << "#StepsObject\n" << mObjectSpaceSplits << endl 
     90                << "#VspOspRatio\n" << VspOspRatio() << endl 
     91                << "#FullMem\n" << mFullMemory << endl 
     92                << "#RenderCostDecrease\n" << mRenderCostDecrease << endl 
     93                << "#FpsPerMb\n" << FpsPerMb() << endl 
     94                << endl; 
     95} 
     96 
     97 
    8198void HierarchyManager::ParseEnvironment() 
    8299{ 
     
    265282{ 
    266283        // question: should I also add the mem usage of the hierarchies? 
    267         const float objectSpaceMem = 0;//GetObjectSpaceMemUsage(); 
    268         const float viewSpaceMem = 0;//mVspTree->GetMemUsage(); 
    269          
    270         // calculate cost in MB 
    271         const float memoryCost = mHierarchyStats.mMemory  / float(1024 * 1024) 
    272                                                          + objectSpaceMem + viewSpaceMem; 
    273  
    274         //cout << "pvs entries " << mHierarchyStats.pvsEntries << endl; 
    275         AddSubdivisionStats(mHierarchyStats.Leaves(), 
    276                                                 mHierarchyStats.mRenderCostDecrease, 
    277                                                 mHierarchyStats.mTotalCost, 
    278                                                 mHierarchyStats.mPvsEntries, 
    279                                                 memoryCost, 
    280                                                 1.0f / (mHierarchyStats.mTotalCost * memoryCost), 
    281                                                 (float)mVspTree->mVspStats.Leaves() / (float)GetObjectSpaceSubdivisionLeaves() 
    282                                                 ); 
     284        const float objectSpaceMem = GetObjectSpaceMemUsage(); 
     285        const float viewSpaceMem = mVspTree->GetMemUsage(); 
     286                 
     287        HierarchySubdivisionStats stats; 
     288        stats.mNumSplits = mHierarchyStats.Leaves(); 
     289        stats.mTotalRenderCost = mHierarchyStats.mTotalCost; 
     290        stats.mEntriesInPvs = mHierarchyStats.mPvsEntries; 
     291        stats.mMemoryCost = mHierarchyStats.mMemory  / float(1024 * 1024); 
     292        stats.mFullMemory = mHierarchyStats.mMemory  / float(1024 * 1024) 
     293                                                + objectSpaceMem + viewSpaceMem; 
     294        stats.mViewSpaceSplits = mVspTree->mVspStats.Leaves(); 
     295        stats.mObjectSpaceSplits = GetObjectSpaceSubdivisionLeaves(); 
     296         
     297        stats.Print(mSubdivisionStats); 
    283298} 
    284299 
     
    299314                        << "#Memory\n" << memory << endl 
    300315                        << "#FpsPerMb\n" << renderCostPerStorage << endl 
    301                         << "#VspOspRatio\n" << vspOspRatio << endl; 
     316                        << "#VspOspRatio\n" << vspOspRatio << endl 
     317                        << endl; 
    302318} 
    303319 
     
    882898 
    883899                        cout << "\nstarting object space subdivision after "  
    884                                  << mVspTree->mVspStats.nodes << " (" << mMinStepsOfSameType << ") " << endl; 
     900                                 << mVspTree->mVspStats.nodes << " (" << mMinStepsOfSameType << ") steps, mem="  
     901                                 << mHierarchyStats.mMemory / float(1024 * 1024) << " MB" << endl; 
    885902 
    886903                        SubdivisionCandidate *ospSc = PrepareObjectSpaceSubdivision(sampleRays, objects); 
     
    897914                        mViewSpaceSubdivisionType = mSavedViewSpaceSubdivisionType; 
    898915 
    899                         cout << "\nstarting view space subdivision at depth "  
     916                        cout << "\nstarting view space subdivision at "  
    900917                                 << GetObjectSpaceSubdivisionLeaves() << " ("  
    901                                  << mMinStepsOfSameType << ") " << endl; 
     918                                 << mMinStepsOfSameType << ") , mem="  
     919                                 << mHierarchyStats.mMemory / float(1024 * 1024) << " MB" << endl; 
    902920 
    903921                        SubdivisionCandidate *vspSc = PrepareViewSpaceSubdivision(sampleRays, objects); 
     
    16021620 
    16031621 
    1604 static void UpdateStats(ofstream &stats, 
    1605                                                 const int splits, 
    1606                                                 const float totalRenderCost, 
    1607                                                 const int entriesInPvs, 
    1608                                                 const float memoryCost, 
    1609                                                 const int viewSpaceSplits, 
    1610                                                 const int objectSpaceSplits) 
    1611 { 
    1612         stats << "#Pass\n" << 0 << endl 
    1613                    << "#Splits\n" << splits << endl  
    1614                    << "#TotalRenderCost\n" << totalRenderCost << endl 
    1615                    << "#TotalEntriesInPvs\n" << entriesInPvs << endl 
    1616                    << "#Memory\n" << memoryCost << endl 
    1617                    << "#ViewSpaceSplits\n" << viewSpaceSplits << endl 
    1618                    << "#ObjectSpaceSplits\n" << objectSpaceSplits << endl 
    1619                    << "#VspOspRatio\n" << (float)viewSpaceSplits / (float)objectSpaceSplits << endl 
    1620                    << endl; 
    1621 } 
    1622  
    1623  
    16241622class HierarchyNodeWrapper; 
    16251623 
     
    18631861                                                                   const ObjectContainer &objects) 
    18641862{ 
    1865         float totalRenderCost = (float)objects.size(); 
    1866         int entriesInPvs = 1; 
    1867         int steps = 0; 
    1868         int viewSpaceSplits = 0; 
    1869         int objectSpaceSplits = 0; 
     1863        HierarchySubdivisionStats subStats; 
     1864        subStats.Reset(); 
     1865 
     1866        ///////////// 
     1867        //-- initial situation 
     1868 
     1869        subStats.mNumSplits = 0; 
     1870        subStats.mTotalRenderCost = (float)objects.size(); 
     1871        subStats.mEntriesInPvs = 1; 
     1872        subStats.mMemoryCost = (float)ObjectPvs::GetEntrySize(); 
     1873        subStats.mFullMemory = subStats.mMemoryCost; 
     1874        subStats.mViewSpaceSplits = 0; 
     1875        subStats.mObjectSpaceSplits = 0; 
     1876         
     1877        subStats.Print(stats); 
    18701878 
    18711879        cout << "exporting vsposp stats ... " << endl; 
    1872         const float memoryCost = (float)entriesInPvs * (float)ObjectPvs::GetEntrySize(); 
    1873  
    1874         ///////////// 
    1875         //-- first view cell 
    1876  
    1877         UpdateStats(stats, 2, totalRenderCost, entriesInPvs, memoryCost, viewSpaceSplits, objectSpaceSplits); 
    18781880 
    18791881        //-- go through tree in the order of render cost decrease 
     
    18981900                         
    18991901                        isLeaf = newNode->IsLeaf(); 
    1900                         rcDecr = oldNode->mRenderCostDecr; 
     1902                        subStats.mRenderCostDecrease = oldNode->mRenderCostDecr; 
    19011903                        entriesIncr = oldNode->mPvsEntriesIncr; 
    19021904                } 
     
    19091911                         
    19101912                        isLeaf = newNode->IsLeaf(); 
    1911                         rcDecr = oldNode->mRenderCostDecr; 
     1913                        subStats.mRenderCostDecrease = oldNode->mRenderCostDecr; 
    19121914                        entriesIncr = oldNode->mPvsEntriesIncr; 
    19131915                }                
     
    19151917                if (!isLeaf) 
    19161918                { 
    1917                         totalRenderCost -= rcDecr; 
    1918                         entriesInPvs += entriesIncr; 
     1919                        subStats.mTotalRenderCost -= subStats.mRenderCostDecrease; 
     1920                        subStats.mEntriesInPvs += entriesIncr; 
     1921 
    19191922                        // if (rcDecr <= 0) 
    19201923                        if (nextCandidate->Type() == SubdivisionCandidate::VIEW_SPACE) 
    19211924                        { 
    1922                                 ++ viewSpaceSplits; 
     1925                                ++ subStats.mViewSpaceSplits; 
    19231926                                cout << "v";//cout << "vsp t: " << timeStamp << " rc: " << rcDecr << " pvs: " << entriesIncr << endl; 
    19241927                        } 
    19251928                        else 
    19261929                        { 
    1927                                 ++ objectSpaceSplits; 
     1930                                ++ subStats.mObjectSpaceSplits; 
    19281931                                cout << "o";//"osp t: " << timeStamp << " rc: " << rcDecr << " pvs: " << entriesIncr << endl; 
    19291932                        } 
    19301933 
    1931                         ++ steps; 
    1932  
    1933                         if ((steps % 500) == 499) 
    1934                                 cout << steps << " steps taken" << endl; 
    1935  
    1936                         const float memoryCost = (float)entriesInPvs * (float)ObjectPvs::GetEntrySize(); 
    1937                         UpdateStats(stats, steps, totalRenderCost, entriesInPvs, memoryCost, viewSpaceSplits, objectSpaceSplits); 
     1934                        ++ subStats.mNumSplits; 
     1935 
     1936                        if ((subStats.mNumSplits % 500) == 499) 
     1937                                cout << subStats.mNumSplits << " steps taken" << endl; 
     1938 
     1939                        subStats.mMemoryCost = (float)subStats.mEntriesInPvs * (float)ObjectPvs::GetEntrySize(); 
     1940                        subStats.mFullMemory = subStats.mMemoryCost; 
     1941 
     1942                        subStats.Print(stats); 
     1943                         
    19381944                } 
    19391945 
     
    20232029                                                                                        const int splitsStepSize) 
    20242030{ 
     2031        HierarchySubdivisionStats subStats; 
     2032         
    20252033        int splits = 0; 
    20262034 
    2027         float renderCost; 
    2028         float memory; 
    2029         int pvsEntries; 
    2030         int viewSpaceSplits; 
    2031         int objectSpaceSplits; 
    2032  
    20332035        while (1) 
    20342036        { 
    2035                 const int numSplits = ExtractStatistics(splits,  
     2037                subStats.mNumSplits = ExtractStatistics(splits,  
    20362038                                                                                                99999.0,  
    2037                                                                                                 renderCost,  
    2038                                                                                                 memory,  
    2039                                                                                                 pvsEntries, 
    2040                                                                                                 viewSpaceSplits, 
    2041                                                                                                 objectSpaceSplits); 
     2039                                                                                                subStats.mTotalRenderCost,  
     2040                                                                                                subStats.mMemoryCost,  
     2041                                                                                                subStats.mEntriesInPvs, 
     2042                                                                                                subStats.mViewSpaceSplits, 
     2043                                                                                                subStats.mObjectSpaceSplits); 
     2044 
    20422045                 
    2043                 UpdateStats(splitsStats,  
    2044                                         numSplits,  
    2045                                         renderCost,  
    2046                                         pvsEntries,  
    2047                                         memory,  
    2048                                         viewSpaceSplits,  
    2049                                         objectSpaceSplits); 
     2046                const float objectSpaceHierarchyMem = float( 
     2047                                                                                          subStats.mObjectSpaceSplits * sizeof(BvhLeaf *) +  
     2048                                                                                          (subStats.mObjectSpaceSplits - 1) * sizeof(BvhInterior *) +  
     2049                                                                                          sizeof(BvHierarchy) 
     2050                                                                                          ) / float(1024 * 1024); 
     2051 
     2052                         
     2053                const float viewSpaceHierarchyMem = float( 
     2054                                                                                        subStats.mViewSpaceSplits * sizeof(VspLeaf *) +  
     2055                                                                                        (subStats.mViewSpaceSplits - 1) * sizeof(VspInterior *) +  
     2056                                                                                        sizeof(VspTree) 
     2057                                                                                        )  / float(1024 * 1024); 
     2058 
     2059                subStats.mFullMemory = subStats.mMemoryCost + objectSpaceHierarchyMem + viewSpaceHierarchyMem; 
     2060                 
     2061                subStats.Print(splitsStats); 
    20502062 
    20512063                splits += splitsStepSize; 
    20522064 
    2053                 if (numSplits == mHierarchyStats.Leaves()) 
     2065                if (subStats.mNumSplits == mHierarchyStats.Leaves()) 
    20542066                        break; 
    20552067        } 
Note: See TracChangeset for help on using the changeset viewer.