[osg][osgearth]osg的分页加载，代码和结构图

DatabasePager加载数据的过程:

多线程 使用DatabasePager加载数据的流程:

左侧的图框表示数据的检索和输入， 中间的白色框表示用于数据存储的内存空间，而右边的图框表示存储数据的输出。此外，蓝色图框表示可以在DatabaseThread线程中完成的工作， 而橙色图框表示由线程之外的函数完成的工作。

 void DatabasePager::DatabaseThread::run()
 {
     OSG_INFO<<_name<<": DatabasePager::DatabaseThread::run"<<std::endl;

     bool firstTime = true;

     osg::ref_ptr<DatabasePager::ReadQueue> read_queue;
     osg::ref_ptr<DatabasePager::ReadQueue> out_queue;

     switch(_mode)
     {
         case(HANDLE_ALL_REQUESTS):
             read_queue = _pager->_fileRequestQueue;
             break;
         case(HANDLE_NON_HTTP):
             read_queue = _pager->_fileRequestQueue;
             out_queue = _pager->_httpRequestQueue;
             break;
         case(HANDLE_ONLY_HTTP):
             read_queue = _pager->_httpRequestQueue;
             break;
     }

     do
     {
         _active = false;

         read_queue->block();

         if (_done)
         {
             break;
         }

         _active = true;

         OSG_INFO<<_name<<": _pager->size()= "<<read_queue->size()<<" to delete = "<<read_queue->_childrenToDeleteList.size()<<std::endl;

         //
         // delete any children if required.
         //
         if (_pager->_deleteRemovedSubgraphsInDatabaseThread/* && !(read_queue->_childrenToDeleteList.empty())*/)
         {
             ObjectList deleteList;
             {
                 // Don't hold lock during destruction of deleteList
                 OpenThreads::ScopedLock<OpenThreads::Mutex> lock(read_queue->_requestMutex);
                 if (!read_queue->_childrenToDeleteList.empty())
                 {
                     deleteList.swap(read_queue->_childrenToDeleteList);
                     read_queue->updateBlock();
                 }
             }
         }

         //
         // load any subgraphs that are required.
         //
         osg::ref_ptr<DatabaseRequest> databaseRequest;
         read_queue->takeFirst(databaseRequest);

         bool readFromFileCache = false;

         osg::ref_ptr<FileCache> fileCache = osgDB::Registry::instance()->getFileCache();
         osg::ref_ptr<FileLocationCallback> fileLocationCallback = osgDB::Registry::instance()->getFileLocationCallback();
         osg::ref_ptr<Options> dr_loadOptions;
         std::string fileName;
         int frameNumberLastRequest = ;
         bool cacheNodes = false;
         if (databaseRequest.valid())
         {
             {
                 OpenThreads::ScopedLock<OpenThreads::Mutex> drLock(_pager->_dr_mutex);
                 dr_loadOptions = databaseRequest->_loadOptions.valid() ? databaseRequest->_loadOptions->cloneOptions() : new osgDB::Options;
                 dr_loadOptions->setTerrain(databaseRequest->_terrain);
                 dr_loadOptions->setParentGroup(databaseRequest->_group);
                 fileName = databaseRequest->_fileName;
                 frameNumberLastRequest = databaseRequest->_frameNumberLastRequest;
             }

             if (dr_loadOptions->getFileCache()) fileCache = dr_loadOptions->getFileCache();
             if (dr_loadOptions->getFileLocationCallback()) fileLocationCallback = dr_loadOptions->getFileLocationCallback();

             // disable the FileCache if the fileLocationCallback tells us that it isn't required for this request.
             if (fileLocationCallback.valid() && !fileLocationCallback->useFileCache()) fileCache = ;

             cacheNodes = (dr_loadOptions->getObjectCacheHint() & osgDB::Options::CACHE_NODES)!=;
             if (cacheNodes)
             {
                 //OSG_NOTICE<<"Checking main ObjectCache"<<std::endl;
                 // check the object cache to see if the file we want has already been loaded.
                 osg::ref_ptr<osg::Object> objectFromCache = osgDB::Registry::instance()->getRefFromObjectCache(fileName);

                 // if no object with fileName in ObjectCache then try the filename appropriate for fileCache
                 if (!objectFromCache && (fileCache.valid() && fileCache->isFileAppropriateForFileCache(fileName)))
                 {
                     if (fileCache->existsInCache(fileName))
                     {
                         objectFromCache = osgDB::Registry::instance()->getRefFromObjectCache(fileCache->createCacheFileName(fileName));
                     }
                 }

                 osg::Node* modelFromCache = dynamic_cast<osg::Node*>(objectFromCache.get());
                 if (modelFromCache)
                 {
                     //OSG_NOTICE<<"Found object in cache "<<fileName<<std::endl;

                     // assign the cached model to the request
                     {
                         OpenThreads::ScopedLock<OpenThreads::Mutex> drLock(_pager->_dr_mutex);
                         databaseRequest->_loadedModel = modelFromCache;
                     }

                     // move the request to the dataToMerge list so it can be merged during the update phase of the frame.
                     {
                         OpenThreads::ScopedLock<OpenThreads::Mutex> listLock( _pager->_dataToMergeList->_requestMutex);
                         _pager->_dataToMergeList->addNoLock(databaseRequest.get());
                         databaseRequest = ;
                     }

                     // skip the rest of the do/while loop as we have done all the processing we need to do.
                     continue;
                 }
                 else
                 {
                     //OSG_NOTICE<<"Not Found object in cache "<<fileName<<std::endl;
                 }

                 // need to disable any attempt to use the cache when loading as we're handle this ourselves to avoid threading conflicts
                 {
                     OpenThreads::ScopedLock<OpenThreads::Mutex> drLock(_pager->_dr_mutex);
                     databaseRequest->_objectCache = new ObjectCache;
                     dr_loadOptions->setObjectCache(databaseRequest->_objectCache.get());
                 }
             }

             // check if databaseRequest is still relevant
             if ((_pager->_frameNumber-frameNumberLastRequest)<=)
             {

                 // now check to see if this request is appropriate for this thread
                 switch(_mode)
                 {
                     case(HANDLE_ALL_REQUESTS):
                     {
                         // do nothing as this thread can handle the load
                         if (fileCache.valid() && fileCache->isFileAppropriateForFileCache(fileName))
                         {
                             if (fileCache->existsInCache(fileName))
                             {
                                 readFromFileCache = true;
                             }
                         }
                         break;
                     }
                     case(HANDLE_NON_HTTP):
                     {
                         // check the cache first
                         bool isHighLatencyFileRequest = false;

                         if (fileLocationCallback.valid())
                         {
                             isHighLatencyFileRequest = fileLocationCallback->fileLocation(fileName, dr_loadOptions.get()) == FileLocationCallback::REMOTE_FILE;
                         }
                         else  if (fileCache.valid() && fileCache->isFileAppropriateForFileCache(fileName))
                         {
                             isHighLatencyFileRequest = true;
                         }

                         if (isHighLatencyFileRequest)
                         {
                             if (fileCache.valid() && fileCache->existsInCache(fileName))
                             {
                                 readFromFileCache = true;
                             }
                             else
                             {
                                 OSG_INFO<<_name<<": Passing http requests over "<<fileName<<std::endl;
                                 out_queue->add(databaseRequest.get());
                                 databaseRequest = ;
                             }
                         }
                         break;
                     }
                     case(HANDLE_ONLY_HTTP):
                     {
                         // accept all requests, as we'll assume only high latency requests will have got here.
                         break;
                     }
                 }
             }
             else
             {
                 databaseRequest = ;
             }
         }

         if (databaseRequest.valid())
         {

             // load the data, note safe to write to the databaseRequest since once
             // it is created this thread is the only one to write to the _loadedModel pointer.
             //OSG_NOTICE<<"In DatabasePager thread readNodeFile("<<databaseRequest->_fileName<<")"<<std::endl;
             //osg::Timer_t before = osg::Timer::instance()->tick();

             // assume that readNode is thread safe...
             ReaderWriter::ReadResult rr = readFromFileCache ?
                         fileCache->readNode(fileName, dr_loadOptions.get(), false) :
                         Registry::instance()->readNode(fileName, dr_loadOptions.get(), false);

             osg::ref_ptr<osg::Node> loadedModel;
             if (rr.validNode()) loadedModel = rr.getNode();
             if (rr.error()) OSG_WARN<<"Error in reading file "<<fileName<<" : "<<rr.message() << std::endl;
             if (rr.notEnoughMemory()) OSG_INFO<<"Not enought memory to load file "<<fileName << std::endl;

             if (loadedModel.valid() &&
                 fileCache.valid() &&
                 fileCache->isFileAppropriateForFileCache(fileName) &&
                 !readFromFileCache)
             {
                 fileCache->writeNode(*(loadedModel), fileName, dr_loadOptions.get());
             }

             {
                 OpenThreads::ScopedLock<OpenThreads::Mutex> drLock(_pager->_dr_mutex);
                 if ((_pager->_frameNumber-databaseRequest->_frameNumberLastRequest)>)
                 {
                     OSG_INFO<<_name<<": Warning DatabaseRquest no longer required."<<std::endl;
                     loadedModel = ;
                 }
             }

             //OSG_NOTICE<<"     node read in "<<osg::Timer::instance()->delta_m(before,osg::Timer::instance()->tick())<<" ms"<<std::endl;

             if (loadedModel.valid())
             {
                 loadedModel->getBound();

                 bool loadedObjectsNeedToBeCompiled = false;
                 osg::ref_ptr<osgUtil::IncrementalCompileOperation::CompileSet> compileSet = ;
                 if (!rr.loadedFromCache())
                 {
                     // find all the compileable rendering objects
                     DatabasePager::FindCompileableGLObjectsVisitor stateToCompile(_pager, _pager->getMarkerObject());
                     loadedModel->accept(stateToCompile);

                     loadedObjectsNeedToBeCompiled = _pager->_doPreCompile &&
                                                     _pager->_incrementalCompileOperation.valid() &&
                                                     _pager->_incrementalCompileOperation->requiresCompile(stateToCompile);

                     // move the databaseRequest from the front of the fileRequest to the end of
                     // dataToCompile or dataToMerge lists.
                     if (loadedObjectsNeedToBeCompiled)
                     {
                         // OSG_NOTICE<<"Using IncrementalCompileOperation"<<std::endl;

                         compileSet = new osgUtil::IncrementalCompileOperation::CompileSet(loadedModel.get());
                         compileSet->buildCompileMap(_pager->_incrementalCompileOperation->getContextSet(), stateToCompile);
                         compileSet->_compileCompletedCallback = new DatabasePagerCompileCompletedCallback(_pager, databaseRequest.get());
                         _pager->_incrementalCompileOperation->add(compileSet.get(), false);
                     }
                 }
                 else
                 {
                     OSG_NOTICE<<"Loaded from ObjectCache"<<std::endl;
                 }

                 {
                     OpenThreads::ScopedLock<OpenThreads::Mutex> drLock(_pager->_dr_mutex);
                     databaseRequest->_loadedModel = loadedModel;
                     databaseRequest->_compileSet = compileSet;
                 }
                 // Dereference the databaseRequest while the queue is
                 // locked. This prevents the request from being
                 // deleted at an unpredictable time within
                 // addLoadedDataToSceneGraph.
                 if (loadedObjectsNeedToBeCompiled)
                 {
                     OpenThreads::ScopedLock<OpenThreads::Mutex> listLock(
                         _pager->_dataToCompileList->_requestMutex);
                     _pager->_dataToCompileList->addNoLock(databaseRequest.get());
                     databaseRequest = ;
                 }
                 else
                 {
                     OpenThreads::ScopedLock<OpenThreads::Mutex> listLock(
                         _pager->_dataToMergeList->_requestMutex);
                     _pager->_dataToMergeList->addNoLock(databaseRequest.get());
                     databaseRequest = ;
                 }

             }

             // _pager->_dataToCompileList->pruneOldRequestsAndCheckIfEmpty();
         }
         else
         {
             OpenThreads::Thread::YieldCurrentThread();
         }

         // go to sleep till our the next time our thread gets scheduled.

         if (firstTime)
         {
             // do a yield to get round a peculiar thread hang when testCancel() is called
             // in certain circumstances - of which there is no particular pattern.
             YieldCurrentThread();
             firstTime = false;
         }

     } while (!testCancel() && !_done);
 }