root/OpenSceneGraph/trunk/src/osgDB/DatabasePager.cpp @ 7038

Revision 7038, 42.1 kB (checked in by robert, 6 years ago)

From Paul Melis, "Here is a list of fixes to misspelled APIs. Unfortunately, more than one
of these are public APIs and therefore will break linkage to existing
shared libraries."

Note from Robert Osfield, updated wrappers.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1#include <osgDB/DatabasePager>
2#include <osgDB/ReadFile>
3
4#include <osg/Geode>
5#include <osg/Timer>
6#include <osg/Texture>
7#include <osg/Notify>
8#include <osg/ApplicationUsage>
9
10#include <OpenThreads/ScopedLock>
11
12#include <algorithm>
13
14#ifdef WIN32
15#include <windows.h>
16#else
17#include <unistd.h>
18#endif
19
20using namespace osgDB;
21using namespace OpenThreads;
22
23static osg::ApplicationUsageProxy DatabasePager_e0(osg::ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_DO_PRE_COMPILE <ON/OFF>","Switch on or off the pre compile of OpenGL object database pager.");
24static osg::ApplicationUsageProxy DatabasePager_e1(osg::ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_MINIMUM_COMPILE_TIME_PER_FRAME <float>","minimum compile time alloted to compiling OpenGL objects per frame in database pager.");
25static osg::ApplicationUsageProxy DatabasePager_e2(osg::ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_MAXIMUM_OBJECTS_TO_COMPILE_PER_FRAME <int>","maximum number of OpenGL objects to compile per frame in database pager.");
26static osg::ApplicationUsageProxy DatabasePager_e3(osg::ApplicationUsage::ENVIRONMENTAL_VARIABLE,"OSG_DATABASE_PAGER_DRAWABLE <mode>","Set the drawable policy for setting of loaded drawable to specified type.  mode can be one of DoNotModify, DisplayList, VBO or VertexArrays>.");
27DatabasePager::DatabasePager()
28{
29    //osg::notify(osg::INFO)<<"Constructing DatabasePager()"<<std::endl;
30   
31    _startThreadCalled = false;
32
33    _done = false;
34    _acceptNewRequests = true;
35    _databasePagerThreadPaused = false;
36   
37    _useFrameBlock = false;
38    _numFramesActive = 0;
39    _frameNumber = 0;
40    _frameBlock = new osg::RefBlock;
41    _databasePagerThreadBlock = new osg::RefBlock;
42
43    _threadPriorityDuringFrame = THREAD_PRIORITY_MIN;
44    _threadPriorityOutwithFrame = THREAD_PRIORITY_MIN;
45
46#if __APPLE__
47    // OSX really doesn't like compiling display lists, and performs poorly when they are used,
48    // so apply this hack to make up for its short comings.
49    _drawablePolicy = USE_VERTEX_ARRAYS;
50#else
51    _drawablePolicy = DO_NOT_MODIFY_DRAWABLE_SETTINGS;
52#endif   
53   
54    const char* str = getenv("OSG_DATABASE_PAGER_GEOMETRY");
55    if (!str) str = getenv("OSG_DATABASE_PAGER_DRAWABLE");
56    if (str)
57    {
58        if (strcmp(str,"DoNotModify")==0)
59        {
60            _drawablePolicy = DO_NOT_MODIFY_DRAWABLE_SETTINGS;
61        }
62        else if (strcmp(str,"DisplayList")==0 || strcmp(str,"DL")==0)
63        {
64            _drawablePolicy = USE_DISPLAY_LISTS;
65        }
66        else if (strcmp(str,"VBO")==0)
67        {
68            _drawablePolicy = USE_VERTEX_BUFFER_OBJECTS;
69        }
70        else if (strcmp(str,"VertexArrays")==0 || strcmp(str,"VA")==0 )
71        {
72            _drawablePolicy = USE_VERTEX_ARRAYS;
73        }
74    }
75
76    _changeAutoUnRef = true;
77    _valueAutoUnRef = true;
78    _changeAnisotropy = false;
79    _valueAnisotropy = 1.0f;
80
81
82#if 1
83    _deleteRemovedSubgraphsInDatabaseThread = true;
84#else
85    _deleteRemovedSubgraphsInDatabaseThread = false;
86#endif
87   
88    _expiryDelay = 10;
89
90    const char* ptr=0;
91    _doPreCompile = true;
92    if( (ptr = getenv("OSG_DO_PRE_COMPILE")) != 0)
93    {
94        _doPreCompile = strcmp(ptr,"yes")==0 || strcmp(ptr,"YES")==0 ||
95                        strcmp(ptr,"on")==0 || strcmp(ptr,"ON")==0;
96    }
97
98    _targetFrameRate = 100.0;
99    _minimumTimeAvailableForGLCompileAndDeletePerFrame = 0.001; // 1ms.
100    _maximumNumOfObjectsToCompilePerFrame = 4;
101    if( (ptr = getenv("OSG_MINIMUM_COMPILE_TIME_PER_FRAME")) != 0)
102    {
103        _minimumTimeAvailableForGLCompileAndDeletePerFrame = atof(ptr);
104    }
105
106    if( (ptr = getenv("OSG_MAXIMUM_OBJECTS_TO_COMPILE_PER_FRAME")) != 0)
107    {
108        _maximumNumOfObjectsToCompilePerFrame = atoi(ptr);
109    }
110
111    // make sure a SharedStateManager exists.
112    //osgDB::Registry::instance()->getOrCreateSharedStateManager();
113   
114    //if (osgDB::Registry::instance()->getSharedStateManager())
115        //osgDB::Registry::instance()->setUseObjectCacheHint(true);
116}
117
118DatabasePager::~DatabasePager()
119{
120    cancel();
121}
122
123int DatabasePager::cancel()
124{
125    int result = 0;
126    if( isRunning() )
127    {
128   
129        _done = true;
130
131        // cancel the thread..
132        // result = Thread::cancel();
133        //join();
134
135        // release the frameBlock and _databasePagerThreadBlock incase its holding up thread cancelation.
136        _frameBlock->release();
137        _databasePagerThreadBlock->release();
138
139        // then wait for the the thread to stop running.
140        while(isRunning())
141        {
142            // commenting out debug info as it was cashing crash on exit, presumable
143            // due to osg::notify or std::cout destructing earlier than this destructor.
144            // osg::notify(osg::DEBUG_INFO)<<"Waiting for DatabasePager to cancel"<<std::endl;
145            OpenThreads::Thread::YieldCurrentThread();
146        }
147       
148        _startThreadCalled = false;
149    }
150    //std::cout<<"DatabasePager::~DatabasePager() stopped running"<<std::endl;
151    return result;
152}
153
154void DatabasePager::clear()
155{
156    {
157        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_fileRequestListMutex);
158        _fileRequestList.clear();
159    }
160
161    {
162        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileListMutex);
163        _dataToCompileList.clear();
164    }
165
166    {
167        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_childrenToDeleteListMutex);
168        _childrenToDeleteList.clear();
169    }
170   
171    {
172        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeListMutex);
173        _dataToMergeList.clear();
174    }
175
176    // no mutex??
177    _activePagedLODList.clear();
178    _inactivePagedLODList.clear();
179   
180    // ??
181    // _activeGraphicsContexts
182}
183
184void DatabasePager::requestNodeFile(const std::string& fileName,osg::Group* group,
185                                    float priority, const osg::FrameStamp* framestamp)
186{
187    requestNodeFile(fileName,group,priority,framestamp,Registry::instance()->getOptions());
188}
189
190void DatabasePager::requestNodeFile(const std::string& fileName,osg::Group* group,
191                                    float priority, const osg::FrameStamp* framestamp,
192                                    ReaderWriter::Options* loadOptions)
193{
194    if (!_acceptNewRequests) return;
195   
196    double timestamp = framestamp?framestamp->getReferenceTime():0.0;
197    int frameNumber = framestamp?framestamp->getFrameNumber():_frameNumber;
198   
199    // search to see if filename already exist in the file loaded list.
200    bool foundEntry = false;
201
202    {
203        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileListMutex);
204   
205        for(DatabaseRequestList::iterator litr = _dataToCompileList.begin();
206            litr != _dataToCompileList.end() && !foundEntry;
207            ++litr)
208        {
209            if ((*litr)->_fileName==fileName)
210            {
211                foundEntry = true;
212                (*litr)->_frameNumberLastRequest = frameNumber;
213                (*litr)->_timestampLastRequest = timestamp;
214                (*litr)->_priorityLastRequest = priority;
215                ++((*litr)->_numOfRequests);
216            }
217        }       
218
219    }
220
221    if (!foundEntry)
222    {
223        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeListMutex);
224
225        for(DatabaseRequestList::iterator litr = _dataToMergeList.begin();
226            litr != _dataToMergeList.end() && !foundEntry;
227            ++litr)
228        {
229            if ((*litr)->_fileName==fileName)
230            {
231                foundEntry = true;
232                (*litr)->_frameNumberLastRequest = frameNumber;
233                (*litr)->_timestampLastRequest = timestamp;
234                (*litr)->_priorityLastRequest = priority;
235                ++((*litr)->_numOfRequests);
236            }
237        }       
238    }
239   
240    if (!foundEntry)
241    {
242   
243        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_fileRequestListMutex);
244
245        // search to see if entry already  in file request list.
246        bool foundEntry = false;
247        for(DatabaseRequestList::iterator ritr = _fileRequestList.begin();
248            ritr != _fileRequestList.end() && !foundEntry;
249            ++ritr)
250        {
251            if ((*ritr)->_fileName==fileName)
252            {
253                foundEntry = true;
254                (*ritr)->_timestampLastRequest = timestamp;
255                (*ritr)->_priorityLastRequest = priority;
256                (*ritr)->_frameNumberLastRequest = frameNumber;
257                ++((*ritr)->_numOfRequests);
258            }
259        }       
260
261        if (!foundEntry)
262        {
263            osg::notify(osg::INFO)<<"In DatabasePager::fileRquest("<<fileName<<")"<<std::endl;
264
265            osg::ref_ptr<DatabaseRequest> databaseRequest = new DatabaseRequest;
266
267            databaseRequest->_fileName = fileName;
268            databaseRequest->_frameNumberFirstRequest = frameNumber;
269            databaseRequest->_timestampFirstRequest = timestamp;
270            databaseRequest->_priorityFirstRequest = priority;
271            databaseRequest->_frameNumberLastRequest = frameNumber;
272            databaseRequest->_timestampLastRequest = timestamp;
273            databaseRequest->_priorityLastRequest = priority;
274            databaseRequest->_groupForAddingLoadedSubgraph = group;
275            databaseRequest->_loadOptions = loadOptions;
276
277            _fileRequestList.push_back(databaseRequest);
278
279            updateDatabasePagerThreadBlock();
280        }
281    }
282   
283    if (!isRunning())
284    {
285        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_run_mutex);
286       
287        if (!_startThreadCalled)
288        {
289            _startThreadCalled = true;
290            _done = false;
291            osg::notify(osg::DEBUG_INFO)<<"DatabasePager::startThread()"<<std::endl;
292            setSchedulePriority(_threadPriorityDuringFrame);
293            startThread();
294        }
295               
296    }
297}
298
299void DatabasePager::signalBeginFrame(const osg::FrameStamp* framestamp)
300{
301
302    if (framestamp)
303    {
304        //osg::notify(osg::INFO) << "signalBeginFrame "<<framestamp->getFrameNumber()<<">>>>>>>>>>>>>>>>"<<std::endl;
305        _frameNumber = framestamp->getFrameNumber();
306       
307    } //else osg::notify(osg::INFO) << "signalBeginFrame >>>>>>>>>>>>>>>>"<<std::endl;
308
309    updateFrameBlock(1);
310
311    if (_numFramesActive>0 && _threadPriorityDuringFrame!=getSchedulePriority())
312        setSchedulePriority(_threadPriorityDuringFrame);
313}
314
315void DatabasePager::signalEndFrame()
316{
317    //osg::notify(osg::INFO) << "signalEndFrame <<<<<<<<<<<<<<<<<<<< "<<std::endl;
318    updateFrameBlock(-1);
319
320    if (_numFramesActive<=0 && _threadPriorityOutwithFrame!=getSchedulePriority())
321        setSchedulePriority(_threadPriorityOutwithFrame);
322
323}
324
325class DatabasePager::FindCompileableGLObjectsVisitor : public osg::NodeVisitor
326{
327public:
328    FindCompileableGLObjectsVisitor(DatabasePager::DataToCompile& dataToCompile,
329                               bool changeAutoUnRef, bool valueAutoUnRef,
330                               bool changeAnisotropy, float valueAnisotropy,
331                               DatabasePager::DrawablePolicy drawablePolicy):
332            osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN),
333            _dataToCompile(dataToCompile),
334            _changeAutoUnRef(changeAutoUnRef), _valueAutoUnRef(valueAutoUnRef),
335            _changeAnisotropy(changeAnisotropy), _valueAnisotropy(valueAnisotropy),
336            _drawablePolicy(drawablePolicy)
337    {
338    }
339   
340    virtual void apply(osg::Node& node)
341    {
342        apply(node.getStateSet());
343
344        traverse(node);
345    }
346   
347    virtual void apply(osg::Geode& geode)
348    {
349        apply(geode.getStateSet());
350   
351        for(unsigned int i=0;i<geode.getNumDrawables();++i)
352        {
353            apply(geode.getDrawable(i));
354        }
355
356        traverse(geode);
357    }
358   
359    inline void apply(osg::StateSet* stateset)
360    {
361        if (stateset)
362        {
363            // search for the existance of any texture object attributes
364            bool foundTextureState = false;
365            for(unsigned int i=0;i<stateset->getTextureAttributeList().size();++i)
366            {
367                osg::Texture* texture = dynamic_cast<osg::Texture*>(stateset->getTextureAttribute(i,osg::StateAttribute::TEXTURE));
368                if (texture)
369                {
370                    if (_changeAutoUnRef) texture->setUnRefImageDataAfterApply(_valueAutoUnRef);
371                    if (_changeAnisotropy) texture->setMaxAnisotropy(_valueAnisotropy);
372                    foundTextureState = true;
373                }
374            }
375
376            // if texture object attributes exist add the state to the list for later compilation.
377            if (foundTextureState)
378            {
379                //osg::notify(osg::DEBUG_INFO)<<"Found compilable texture state"<<std::endl;
380                _dataToCompile.first.insert(stateset);
381            }
382        }
383    }
384   
385    inline void apply(osg::Drawable* drawable)
386    {
387        apply(drawable->getStateSet());
388       
389        switch(_drawablePolicy)
390        {
391        case DatabasePager::DO_NOT_MODIFY_DRAWABLE_SETTINGS:
392             // do nothing, leave settings as they came in from loaded database.
393             // osg::notify(osg::NOTICE)<<"DO_NOT_MODIFY_DRAWABLE_SETTINGS"<<std::endl;
394             break;
395        case DatabasePager::USE_DISPLAY_LISTS:
396             drawable->setUseDisplayList(true);
397             drawable->setUseVertexBufferObjects(false);
398             break;
399        case DatabasePager::USE_VERTEX_BUFFER_OBJECTS:
400             drawable->setUseDisplayList(true);
401             drawable->setUseVertexBufferObjects(true);
402             // osg::notify(osg::NOTICE)<<"USE_VERTEX_BUFFER_OBJECTS"<<std::endl;
403             break;
404        case DatabasePager::USE_VERTEX_ARRAYS:
405             drawable->setUseDisplayList(false);
406             drawable->setUseVertexBufferObjects(false);
407             // osg::notify(osg::NOTICE)<<"USE_VERTEX_ARRAYS"<<std::endl;
408             break;
409        }
410       
411        if (drawable->getUseDisplayList() || drawable->getUseVertexBufferObjects())
412        {
413            // osg::notify(osg::NOTICE)<<"  Found compilable drawable"<<std::endl;
414            _dataToCompile.second.push_back(drawable);
415        }
416    }
417   
418    DatabasePager::DataToCompile&   _dataToCompile;
419    bool                            _changeAutoUnRef;
420    bool                            _valueAutoUnRef;
421    bool                            _changeAnisotropy;
422    float                           _valueAnisotropy;
423    DatabasePager::DrawablePolicy   _drawablePolicy;
424};
425
426
427struct DatabasePager::SortFileRequestFunctor
428{
429    bool operator() (const osg::ref_ptr<DatabasePager::DatabaseRequest>& lhs,const osg::ref_ptr<DatabasePager::DatabaseRequest>& rhs) const
430    {
431        if (lhs->_timestampLastRequest>rhs->_timestampLastRequest) return true;
432        else if (lhs->_timestampLastRequest<rhs->_timestampLastRequest) return false;
433        else return (lhs->_priorityLastRequest>rhs->_priorityLastRequest);
434    }
435};
436
437
438void DatabasePager::setDatabasePagerThreadPause(bool pause)
439{
440    _databasePagerThreadPaused = pause;
441    updateDatabasePagerThreadBlock();
442}
443
444void DatabasePager::run()
445{
446    osg::notify(osg::INFO)<<"DatabasePager::run()"<<std::endl;
447
448    // need to set the texture object manager to be able to reuse textures
449    osg::Texture::setMinimumNumberOfTextureObjectsToRetainInCache(100);
450   
451    // need to set the texture object manager to be able to reuse textures
452    osg::Drawable::setMinimumNumberOfDisplayListsToRetainInCache(500);
453
454    bool firstTime = true;
455   
456    do
457    {
458
459        _databasePagerThreadBlock->block();
460
461        if (_useFrameBlock)
462        {
463            _frameBlock->block();
464        }     
465
466        //
467        // delete any children if required.
468        //
469        if (_deleteRemovedSubgraphsInDatabaseThread)
470        {
471            osg::ref_ptr<osg::Object> obj = 0;
472            {
473                OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_childrenToDeleteListMutex);
474                if (!_childrenToDeleteList.empty())
475                {
476                    //osg::notify(osg::NOTICE)<<"In DatabasePager thread deleting "<<_childrenToDeleteList.size()<<" objects"<<std::endl;
477                    //osg::Timer_t before = osg::Timer::instance()->tick();
478                    obj = _childrenToDeleteList.back();
479                    _childrenToDeleteList.pop_back();
480                    //osg::notify(osg::NOTICE)<<"Done DatabasePager thread deleted in "<<osg::Timer::instance()->delta_m(before,osg::Timer::instance()->tick())<<" ms"<<" objects"<<std::endl;
481
482                    updateDatabasePagerThreadBlock();
483
484                }
485            }
486        }
487
488        //
489        // load any subgraphs that are required.
490        //
491        osg::ref_ptr<DatabaseRequest> databaseRequest;
492   
493        // get the front of the file request list.
494        {
495            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_fileRequestListMutex);
496            if (!_fileRequestList.empty())
497            {
498                std::sort(_fileRequestList.begin(),_fileRequestList.end(),SortFileRequestFunctor());
499                databaseRequest = _fileRequestList.front();
500            }
501        }
502               
503        if (databaseRequest.valid())
504        {
505            // check if databaseRequest is still relevant
506            if (_frameNumber-databaseRequest->_frameNumberLastRequest<=1)
507            {
508                       
509                // load the data, note safe to write to the databaseRequest since once
510                // it is created this thread is the only one to write to the _loadedModel pointer.
511                //osg::notify(osg::NOTICE)<<"In DatabasePager thread readNodeFile("<<databaseRequest->_fileName<<")"<<std::endl;
512                //osg::Timer_t before = osg::Timer::instance()->tick();
513               
514               
515                bool serialize_readNodeFile = true;
516                if (serialize_readNodeFile)
517                {
518                    // do *not* assume that we only have one DatabasePager, or that reaNodeFile is thread safe...
519                    static OpenThreads::Mutex s_serialize_readNodeFile_mutex;
520                    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_serialize_readNodeFile_mutex);
521                    databaseRequest->_loadedModel = osgDB::readNodeFile(databaseRequest->_fileName,
522                        databaseRequest->_loadOptions.get());
523                }
524                else
525                {
526                    // assume that we only have one DatabasePager, or that readNodeFile is thread safe...
527                    databaseRequest->_loadedModel = osgDB::readNodeFile(databaseRequest->_fileName,
528                        databaseRequest->_loadOptions.get());
529                }
530                   
531                //osg::notify(osg::NOTICE)<<"     node read in "<<osg::Timer::instance()->delta_m(before,osg::Timer::instance()->tick())<<" ms"<<std::endl;
532               
533                bool loadedObjectsNeedToBeCompiled = false;
534
535                if (_doPreCompile && databaseRequest->_loadedModel.valid() && !_activeGraphicsContexts.empty())
536                {
537                    // force a compute of the loaded model's bounding volume, so that when the subgraph
538                    // merged with the main scene graph and large computeBound() isn't incurred.
539                    databaseRequest->_loadedModel->getBound();
540
541
542                    ActiveGraphicsContexts::iterator itr = _activeGraphicsContexts.begin();
543
544                    DataToCompile& dtc = databaseRequest->_dataToCompileMap[*itr];
545                    ++itr;               
546
547                    // find all the compileable rendering objects
548                    FindCompileableGLObjectsVisitor frov(dtc,
549                                                         _changeAutoUnRef, _valueAutoUnRef,
550                                                         _changeAnisotropy, _valueAnisotropy,
551                                                         _drawablePolicy);
552
553                    databaseRequest->_loadedModel->accept(frov);
554
555                    if (!dtc.first.empty() || !dtc.second.empty())
556                    {
557                        loadedObjectsNeedToBeCompiled = true;               
558
559                        // copy the objects from the compile list to the other graphics context list.
560                        for(;
561                            itr != _activeGraphicsContexts.end();
562                            ++itr)
563                        {
564                            databaseRequest->_dataToCompileMap[*itr] = dtc;
565                        }
566                    }
567                }           
568
569                // move the databaseRequest from the front of the fileRequest to the end of
570                // dataToCompile or dataToMerge lists.
571                {
572                    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_fileRequestListMutex);
573
574                    DatabaseRequestList::iterator itr = std::find(_fileRequestList.begin(),_fileRequestList.end(),databaseRequest);
575                    if (itr != _fileRequestList.end())
576                    {
577                        if (databaseRequest->_loadedModel.valid())
578                        {
579                            if (loadedObjectsNeedToBeCompiled)
580                            {
581                                OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileListMutex);
582                                _dataToCompileList.push_back(databaseRequest);
583                            }
584                            else
585                            {
586                                OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeListMutex);
587                                _dataToMergeList.push_back(databaseRequest);
588                            }
589                        }       
590
591                        _fileRequestList.erase(itr);
592                    }
593
594                    updateDatabasePagerThreadBlock();
595                }
596               
597                if (loadedObjectsNeedToBeCompiled && !_compileGraphicsContexts.empty())
598                {
599                    for(CompileGraphicsContexts::iterator citr = _compileGraphicsContexts.begin();
600                        citr != _compileGraphicsContexts.end();
601                        ++citr)
602                    {
603                        osg::GraphicsContext* gc = citr->get();
604                        if (gc)
605                        {   
606                            osg::OperationsThread* gt = gc->getGraphicsThread();                           
607                            if (gt) gt->add(new DatabasePager::CompileOperation(this));
608                            else
609                            {
610                                gc->makeCurrent();
611                               
612                                // osg::notify(osg::NOTICE)<<"Database pager thread compiling"<<std::endl;
613                               
614                                compileAllGLObjects(*(gc->getState()));
615                               
616                                gc->releaseContext();
617                            }
618                        }
619                    }
620                    // osg::notify(osg::NOTICE)<<"Done compiling in paging thread"<<std::endl;                   
621                }
622               
623            }
624            else
625            {
626                //std::cout<<"frame number delta for "<<databaseRequest->_fileName<<" "<<_frameNumber-databaseRequest->_frameNumberLastRequest<<std::endl;
627                // remove the databaseRequest from the front of the fileRequest to the end of
628                // dataLoad list as its is no longer relevant
629                OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_fileRequestListMutex);
630
631                if (!_fileRequestList.empty()) _fileRequestList.erase(_fileRequestList.begin());
632
633                updateDatabasePagerThreadBlock();
634
635            }
636        }
637       
638        // go to sleep till our the next time our thread gets scheduled.
639
640        if (firstTime)
641        {
642            // do a yield to get round a peculiar thread hang when testCancel() is called
643            // in certain cirumstances - of which there is no particular pattern.
644            YieldCurrentThread();
645            firstTime = false;
646        }
647
648    } while (!testCancel() && !_done);
649
650}
651
652
653bool DatabasePager::requiresUpdateSceneGraph() const
654{
655    {
656        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeListMutex);
657        if (!_dataToMergeList.empty()) return true;
658    }
659   
660    return false;
661   
662}
663 
664
665void DatabasePager::addLoadedDataToSceneGraph(double timeStamp)
666{
667
668    // osg::Timer_t before = osg::Timer::instance()->tick();
669
670    DatabaseRequestList localFileLoadedList;
671
672    // get the dat for the _dataToCompileList, leaving it empty via a std::vector<>.swap.
673    {
674        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeListMutex);
675        localFileLoadedList.swap(_dataToMergeList);
676    }
677       
678    // add the loaded data into the scene graph.
679    for(DatabaseRequestList::iterator itr=localFileLoadedList.begin();
680        itr!=localFileLoadedList.end();
681        ++itr)
682    {
683        DatabaseRequest* databaseRequest = itr->get();
684
685        // osg::notify(osg::NOTICE)<<"Merging "<<_frameNumber-(*itr)->_frameNumberLastRequest<<std::endl;
686       
687        if (osgDB::Registry::instance()->getSharedStateManager())
688            osgDB::Registry::instance()->getSharedStateManager()->share(databaseRequest->_loadedModel.get());
689
690       
691        registerPagedLODs(databaseRequest->_loadedModel.get());
692       
693        osg::Group* group = databaseRequest->_groupForAddingLoadedSubgraph.get();
694        osg::PagedLOD* plod = dynamic_cast<osg::PagedLOD*>(group);
695        if (plod)
696        {
697            plod->setTimeStamp(plod->getNumChildren(),timeStamp);
698        }
699        group->addChild(databaseRequest->_loadedModel.get());
700        osg::notify(osg::INFO)<<"merged subgraph"<<databaseRequest->_fileName<<" after "<<databaseRequest->_numOfRequests<<" requests."<<std::endl;
701
702    }
703
704    // osg::notify(osg::NOTICE)<<"Done DatabasePager::addLoadedDataToSceneGraph"<<osg::Timer::instance()->delta_m(before,osg::Timer::instance()->tick())<<" ms  objects"<<localFileLoadedList.size()<<std::endl;
705   
706}
707
708
709void DatabasePager::removeExpiredSubgraphs(double currentFrameTime)
710{
711    //osg::notify(osg::NOTICE)<<"DatabasePager::removeExpiredSubgraphs()"<<std::endl;
712
713    // osg::Timer_t before = osg::Timer::instance()->tick();
714
715    double expiryTime = currentFrameTime - _expiryDelay;
716
717    osg::NodeList childrenRemoved;
718   
719
720    for(PagedLODList::iterator active_itr = _activePagedLODList.begin();
721        active_itr!=_activePagedLODList.end();
722        )
723    {
724        const osg::PagedLOD* plod = active_itr->get();
725        bool remove_plod = false;
726        if (plod->referenceCount()<=1)
727        {
728            // prune PageLOD's that are no longer externally referenced
729            childrenRemoved.push_back(const_cast<osg::PagedLOD*>(plod));
730            //osg::notify(osg::NOTICE)<<"_activePagedLODList : pruning no longer externally referenced"<<std::endl;
731            remove_plod = true;
732        }
733        else if (plod->getFrameNumberOfLastTraversal()<_frameNumber)
734        {               
735            // osg::notify(osg::NOTICE)<<"_activePagedLODList : moving PageLOD to inactive list"<<std::endl;
736            _inactivePagedLODList.push_back(*active_itr);
737            remove_plod = true;
738        }
739       
740        if (remove_plod)
741        {
742            PagedLODList::iterator itr_to_erase = active_itr;
743            ++active_itr;
744           
745            _activePagedLODList.erase(itr_to_erase);           
746        }
747        else
748        {
749            ++active_itr;
750        }
751    }
752   
753    unsigned int i = 0;
754    // unsigned int numberOfPagedLODToTest = _inactivePagedLODList.size();
755    unsigned int targetNumOfInActivePagedLODs = 100;
756    unsigned int targetNumOfRemovedChildPagedLODs = 0;
757    if (_inactivePagedLODList.size()>targetNumOfInActivePagedLODs) targetNumOfRemovedChildPagedLODs = _inactivePagedLODList.size()-targetNumOfInActivePagedLODs;
758   
759    if (targetNumOfRemovedChildPagedLODs>1) targetNumOfRemovedChildPagedLODs=1;
760   
761
762    // filter out singly referenced PagedLOD and move reactivated PagedLOD into the active list
763    for(PagedLODList::iterator inactive_itr = _inactivePagedLODList.begin();
764        inactive_itr!=_inactivePagedLODList.end();
765        )
766    {
767        const osg::PagedLOD* plod = inactive_itr->get();
768        bool remove_plod = false;
769        if (plod->referenceCount()<=1)
770        {
771            // prune PageLOD's that are no longer externally referenced
772            childrenRemoved.push_back(const_cast<osg::PagedLOD*>(plod));
773            //osg::notify(osg::NOTICE)<<"_activePagedLODList : pruning no longer externally referenced"<<std::endl;
774            remove_plod = true;
775        }
776        else if (plod->getFrameNumberOfLastTraversal()>=_frameNumber)
777        {
778            // osg::notify(osg::NOTICE)<<"_inactivePagedLODList : moving PageLOD to active list"<<std::endl;
779            // found a reactivated pagedLOD's need to put it back in the active list.               
780            _activePagedLODList.push_back(*inactive_itr);
781            remove_plod = true;
782        }
783       
784        if (remove_plod)
785        {
786            PagedLODList::iterator itr_to_erase = inactive_itr;
787            ++inactive_itr;
788           
789            _inactivePagedLODList.erase(itr_to_erase);           
790        }
791        else
792        {
793//            if (i<numberOfPagedLODToTest)
794            if (childrenRemoved.size()<targetNumOfRemovedChildPagedLODs)
795            {
796                // check for removing expired children.
797                if (const_cast<osg::PagedLOD*>(plod)->removeExpiredChildren(expiryTime,childrenRemoved))
798                {
799                    //osg::notify(osg::NOTICE)<<"Some children removed from PLod"<<std::endl;
800                }
801                else
802                {
803                    // osg::notify(osg::NOTICE)<<"no children removed from PLod"<<std::endl;
804                }
805            }
806       
807            ++inactive_itr;
808            ++i;
809        }
810    }
811
812    //osg::notify(osg::NOTICE)<<"_activePagedLODList.size()="<<_activePagedLODList.size()<<"\t_inactivePagedLODList.size()="<<_inactivePagedLODList.size()<<std::endl;
813
814
815    // osg::notify(osg::NOTICE)<<"   number stale "<<numberStale<<"  number active "<<_pagedLODList.size()-numberStale<<std::endl;
816
817    //double t = osg::Timer::instance()->delta_m(before,osg::Timer::instance()->tick());
818    //osg::notify(osg::NOTICE)<<"   time 1 "<<t<<" ms "<<_pagedLODList.size()<<" pagedLOD's"<<std::endl;
819    //osg::notify(osg::NOTICE)<<"   average time = "<<t/(double)_pagedLODList.size()<<" ms/per PagedLOD"<<std::endl;
820
821    if (!childrenRemoved.empty())
822    {
823        // pass the objects across to the database pager delete list
824        if (_deleteRemovedSubgraphsInDatabaseThread)
825        {
826            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_childrenToDeleteListMutex);
827            for (osg::NodeList::iterator critr = childrenRemoved.begin();
828                 critr!=childrenRemoved.end();
829                 ++critr)
830            {
831                _childrenToDeleteList.push_back(critr->get());
832            }
833            updateDatabasePagerThreadBlock();
834        }
835
836        childrenRemoved.clear();
837    }
838
839    // osg::notify(osg::NOTICE)<<"   time 2 "<<osg::Timer::instance()->delta_m(before,osg::Timer::instance()->tick())<<" ms "<<std::endl;
840
841   
842    if (osgDB::Registry::instance()->getSharedStateManager())
843        osgDB::Registry::instance()->getSharedStateManager()->prune();
844
845    // update the Registry object cache.
846    osgDB::Registry::instance()->updateTimeStampOfObjectsInCacheWithExternalReferences(currentFrameTime);
847    osgDB::Registry::instance()->removeExpiredObjectsInCache(expiryTime);
848
849
850    // osg::notify(osg::NOTICE)<<"Done DatabasePager::removeExpiredSubgraphs() "<<osg::Timer::instance()->delta_m(before,osg::Timer::instance()->tick())<<" ms "<<std::endl;
851
852}
853
854
855class DatabasePager::FindPagedLODsVisitor : public osg::NodeVisitor
856{
857public:
858    FindPagedLODsVisitor(DatabasePager::PagedLODList& pagedLODList):
859        osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN),
860        _pagedLODList(pagedLODList)
861    {
862    }
863   
864    virtual void apply(osg::PagedLOD& plod)
865    {
866        _pagedLODList.push_back(&plod);
867   
868        traverse(plod);
869    }
870   
871    DatabasePager::PagedLODList& _pagedLODList;
872};
873
874void DatabasePager::registerPagedLODs(osg::Node* subgraph)
875{
876    FindPagedLODsVisitor fplv(_activePagedLODList);
877    if (subgraph) subgraph->accept(fplv);
878}
879
880bool DatabasePager::requiresCompileGLObjects() const
881{
882    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileListMutex);
883    return !_dataToCompileList.empty();
884}
885
886void DatabasePager::addCompileGraphicsContext(osg::GraphicsContext* gc)
887{
888    for(CompileGraphicsContexts::iterator itr = _compileGraphicsContexts.begin();
889        itr != _compileGraphicsContexts.end();
890        ++itr)
891    {
892        if (*itr == gc)
893        {
894            return;
895        }
896    }
897   
898    _compileGraphicsContexts.push_back(gc);
899   
900    setCompileGLObjectsForContextID(gc->getState()->getContextID(),true);
901}
902
903void DatabasePager::removeCompileGraphicsContext(osg::GraphicsContext* gc)
904{
905    for(CompileGraphicsContexts::iterator itr = _compileGraphicsContexts.begin();
906        itr != _compileGraphicsContexts.end();
907        ++itr)
908    {
909        if (*itr == gc)
910        {
911            _compileGraphicsContexts.erase(itr);
912            return;
913        }
914    }
915}
916
917void DatabasePager::setCompileGLObjectsForContextID(unsigned int contextID, bool on)
918{
919    if (on)
920    {
921        _activeGraphicsContexts.insert(contextID);
922    }
923    else
924    {
925        _activeGraphicsContexts.erase(contextID);
926    }
927}
928
929bool DatabasePager::getCompileGLObjectsForContextID(unsigned int contextID)
930{
931    return _activeGraphicsContexts.count(contextID)!=0;
932}
933
934
935DatabasePager::CompileOperation::CompileOperation(osgDB::DatabasePager* databasePager):
936    osg::Operation("DatabasePager::CompileOperation",false),
937    _databasePager(databasePager)
938{
939}
940
941void DatabasePager::CompileOperation::operator () (osg::Object* object)
942{
943    osg::GraphicsContext* context = dynamic_cast<osg::GraphicsContext*>(object);
944    if (!context) return;
945
946    // osg::notify(osg::NOTICE)<<"Background thread compiling"<<std::endl;
947    if (_databasePager.valid()) _databasePager->compileAllGLObjects(*(context->getState()));
948   
949}
950
951bool DatabasePager::requiresExternalCompileGLObjects(unsigned int contextID) const
952{
953    if (_activeGraphicsContexts.count(contextID)==0) return false;
954   
955    for(CompileGraphicsContexts::const_iterator citr = _compileGraphicsContexts.begin();
956        citr != _compileGraphicsContexts.end();
957        ++citr)
958    {
959        const osg::GraphicsContext* gc = citr->get();
960        if (gc && gc->getState()->getContextID()==contextID) return false;
961    }
962
963    return true;   
964}
965
966void DatabasePager::compileAllGLObjects(osg::State& state)
967{
968    double availableTime = DBL_MAX;
969    compileGLObjects(state, availableTime);
970}
971
972void DatabasePager::compileGLObjects(osg::State& state, double& availableTime)
973{
974    // osg::notify(osg::NOTICE)<<"DatabasePager::compileGLObjects "<<_frameNumber<<std::endl;
975
976    bool compileAll = (availableTime==DBL_MAX);
977
978    osg::RenderInfo renderInfo;
979    renderInfo.setState(&state);
980
981    if (availableTime>0.0)
982    {
983
984        const osg::Timer& timer = *osg::Timer::instance();
985        osg::Timer_t start_tick = timer.tick();
986        double elapsedTime = 0.0;
987        double estimatedTextureDuration = 0.0001;
988        double estimatedDrawableDuration = 0.0001;
989
990        osg::ref_ptr<DatabaseRequest> databaseRequest;
991
992        // get the first compileable entry.
993        {
994            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileListMutex);
995            if (!_dataToCompileList.empty())
996            {
997                std::sort(_dataToCompileList.begin(),_dataToCompileList.end(),SortFileRequestFunctor());
998
999                // prune all the old entries.
1000                DatabaseRequestList::iterator litr;
1001                int i=0;
1002                for(litr = _dataToCompileList.begin();
1003                    (litr != _dataToCompileList.end()) && (_frameNumber-(*litr)->_frameNumberLastRequest)<=1;
1004                    ++litr,i++)
1005                {
1006                    //osg::notify(osg::NOTICE)<<"Compile "<<_frameNumber-(*litr)->_frameNumberLastRequest<<std::endl;
1007                }
1008                if (litr != _dataToCompileList.end())
1009                {
1010                    if (_deleteRemovedSubgraphsInDatabaseThread)
1011                    {
1012                        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_childrenToDeleteListMutex);
1013
1014                        for(DatabaseRequestList::iterator ditr=litr;
1015                            ditr!=_dataToCompileList.end();
1016                            ++ditr)
1017                        {
1018                            _childrenToDeleteList.push_back((*ditr)->_loadedModel.get());
1019                        }
1020                    }
1021                    //osg::notify(osg::NOTICE)<<"Pruning "<<_dataToCompileList.size()-i<<std::endl;
1022                    _dataToCompileList.erase(litr,_dataToCompileList.end());
1023                }
1024
1025                // advance to the next entry to compile if one is available.
1026                databaseRequest = _dataToCompileList.empty() ? 0 : _dataToCompileList.front();
1027           
1028            }
1029        };
1030
1031        unsigned int numObjectsCompiled = 0;
1032
1033        // while there are valid databaseRequest's in the to compile list and there is
1034        // sufficient time left compile each databaseRequest's stateset and drawables.
1035        while (databaseRequest.valid() && (compileAll || (elapsedTime<availableTime && numObjectsCompiled<_maximumNumOfObjectsToCompilePerFrame)) )
1036        {
1037            DataToCompileMap& dcm = databaseRequest->_dataToCompileMap;
1038            DataToCompile& dtc = dcm[state.getContextID()];
1039            if (!dtc.first.empty() && (elapsedTime+estimatedTextureDuration)<availableTime && numObjectsCompiled<_maximumNumOfObjectsToCompilePerFrame)
1040            {
1041
1042                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_PRIORITY, 1.0);
1043
1044                // we have StateSet's to compile
1045                StateSetList& sslist = dtc.first;
1046                //osg::notify(osg::INFO)<<"Compiling statesets"<<std::endl;
1047                StateSetList::iterator itr=sslist.begin();
1048                for(;
1049                    itr!=sslist.end() && (elapsedTime+estimatedTextureDuration)<availableTime && numObjectsCompiled<_maximumNumOfObjectsToCompilePerFrame;
1050                    ++itr)
1051                {
1052                    //osg::notify(osg::INFO)<<"    Compiling stateset "<<(*itr).get()<<std::endl;
1053
1054                    double startCompileTime = timer.delta_s(start_tick,timer.tick());
1055
1056                    (*itr)->compileGLObjects(state);
1057
1058                    GLint p;
1059                    glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_RESIDENT, &p);
1060
1061                    elapsedTime = timer.delta_s(start_tick,timer.tick());
1062
1063
1064                    // estimate the duration of the compile based on current compile duration.
1065                    estimatedTextureDuration = (elapsedTime-startCompileTime);
1066
1067                    ++numObjectsCompiled;
1068                }
1069                // remove the compiled stateset from the list.
1070                sslist.erase(sslist.begin(),itr);
1071            }
1072
1073            if (!dtc.second.empty() && (compileAll || ((elapsedTime+estimatedDrawableDuration)<availableTime && numObjectsCompiled<_maximumNumOfObjectsToCompilePerFrame)))
1074            {
1075                // we have Drawable's to compile
1076                //osg::notify(osg::INFO)<<"Compiling drawables"<<std::endl;
1077                DrawableList& dwlist = dtc.second;
1078                DrawableList::iterator itr=dwlist.begin();
1079                for(;
1080                    itr!=dwlist.end() && (compileAll || ((elapsedTime+estimatedDrawableDuration)<availableTime && numObjectsCompiled<_maximumNumOfObjectsToCompilePerFrame));
1081                    ++itr)
1082                {
1083                    //osg::notify(osg::INFO)<<"    Compiling drawable "<<(*itr).get()<<std::endl;
1084                    double startCompileTime = timer.delta_s(start_tick,timer.tick());
1085                    (*itr)->compileGLObjects(renderInfo);
1086                    elapsedTime = timer.delta_s(start_tick,timer.tick());
1087
1088                    // estimate the duration of the compile based on current compile duration.
1089                    estimatedDrawableDuration = (elapsedTime-startCompileTime);
1090
1091                    ++numObjectsCompiled;
1092
1093                }
1094                // remove the compiled drawables from the list.
1095                dwlist.erase(dwlist.begin(),itr);
1096            }
1097
1098            //osg::notify(osg::INFO)<<"Checking if compiled"<<std::endl;
1099
1100            // now check the to compile entries for all active graphics contexts
1101            // to make sure that all have been compiled.
1102            bool allCompiled = true;
1103            for(DataToCompileMap::iterator itr=dcm.begin();
1104                itr!=dcm.end() && allCompiled;
1105                ++itr)
1106            {
1107                if (!(itr->second.first.empty())) allCompiled=false;
1108                if (!(itr->second.second.empty())) allCompiled=false;
1109            }
1110
1111
1112            if (allCompiled)
1113            {
1114                // we've compile all of the current databaseRequest so we can now pop it off the
1115                // osg::notify(osg::NOTICE)<<"All compiled"<<std::endl;
1116
1117                // to compile list and place it on the merge list.
1118                OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileListMutex);
1119
1120                {
1121                    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeListMutex);
1122                    _dataToMergeList.push_back(databaseRequest);
1123                }
1124
1125                if (!_dataToCompileList.empty()) _dataToCompileList.erase(_dataToCompileList.begin());
1126
1127                if (!_dataToCompileList.empty())
1128                {
1129                    std::sort(_dataToCompileList.begin(),_dataToCompileList.end(),SortFileRequestFunctor());
1130                    databaseRequest = _dataToCompileList.front();
1131                }
1132                else databaseRequest = 0;
1133
1134            }
1135            else 
1136            {
1137                // osg::notify(osg::NOTICE)<<"Not all compiled"<<std::endl;
1138                databaseRequest = 0;
1139            }
1140
1141            elapsedTime = timer.delta_s(start_tick,timer.tick());
1142        }
1143
1144        availableTime -= elapsedTime;
1145
1146        //osg::notify(osg::NOTICE)<<"elapsedTime="<<elapsedTime<<"\ttime remaining ="<<availableTime<<"\tnumObjectsCompiled = "<<numObjectsCompiled<<std::endl;
1147        //osg::notify(osg::NOTICE)<<"estimatedTextureDuration="<<estimatedTextureDuration;
1148        //osg::notify(osg::NOTICE)<<"\testimatedDrawableDuration="<<estimatedDrawableDuration<<std::endl;
1149    }
1150    else
1151    {
1152        availableTime = 0.0f;
1153    }
1154}
Note: See TracBrowser for help on using the browser.