Changeset 8434

Show
Ignore:
Timestamp:
06/12/08 18:33:24
Author:
robert
Message:

Refactored the management of the request queues so that the appropraite mutex is locked when DatabaseRequest? objects are modified

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • OpenSceneGraph/trunk/src/osgDB/DatabasePager.cpp

    r8403 r8434  
    239239///////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
    240240// 
    241 //  RequestQueue 
     241//  ReadQueue 
    242242// 
    243 DatabasePager::RequestQueue::RequestQueue(DatabasePager* pager, const std::string& name): 
     243DatabasePager::ReadQueue::ReadQueue(DatabasePager* pager, const std::string& name): 
    244244    _pager(pager), 
    245245    _name(name) 
    …… 
    248248} 
    249249 
    250 void DatabasePager::RequestQueue::clear() 
     250void DatabasePager::ReadQueue::clear() 
    251251{ 
    252252    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_requestMutex); 
     253 
     254    for(RequestList::iterator citr = _requestList.begin(); 
     255        citr != _requestList.end(); 
     256        ++citr) 
     257    { 
     258        (*citr)->_loadedModel = 0; 
     259        (*citr)->_requestQueue = 0; 
     260    } 
     261 
    253262    _requestList.clear(); 
    254263 
    …… 
    256265} 
    257266 
    258 void DatabasePager::RequestQueue::add(DatabasePager::DatabaseRequest* databaseRequest) 
     267void DatabasePager::ReadQueue::add(DatabasePager::DatabaseRequest* databaseRequest) 
    259268{ 
    260269    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_requestMutex); 
    261270    _requestList.push_back(databaseRequest); 
     271    databaseRequest->_requestQueue = this; 
    262272 
    263273    updateBlock(); 
    264274} 
    265275 
    266 void DatabasePager::RequestQueue::takeFirst(osg::ref_ptr<DatabaseRequest>& databaseRequest) 
     276void DatabasePager::ReadQueue::takeFirst(osg::ref_ptr<DatabaseRequest>& databaseRequest) 
    267277{ 
    268278    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_requestMutex); 
    …… 
    272282        _requestList.sort(SortFileRequestFunctor()); 
    273283        databaseRequest = _requestList.front(); 
     284        databaseRequest->_requestQueue = 0; 
    274285        _requestList.erase(_requestList.begin()); 
    275286 
    …… 
    365376    bool firstTime = true; 
    366377     
    367     osg::ref_ptr<DatabasePager::RequestQueue> read_queue; 
    368     osg::ref_ptr<DatabasePager::RequestQueue> out_queue; 
     378    osg::ref_ptr<DatabasePager::ReadQueue> read_queue; 
     379    osg::ref_ptr<DatabasePager::ReadQueue> out_queue; 
    369380     
    370381    switch(_mode) 
    …… 
    631642                if (loadedObjectsNeedToBeCompiled) 
    632643                { 
    633                     OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_pager->_dataToCompileListMutex); 
    634                     _pager->_dataToCompileList.push_back(databaseRequest); 
     644                    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_pager->_dataToCompileList->_requestMutex); 
     645                    databaseRequest->_requestQueue = _pager->_dataToCompileList.get(); 
     646                    _pager->_dataToCompileList->_requestList.push_back(databaseRequest); 
    635647                } 
    636648                else 
    637649                { 
    638                     OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_pager->_dataToMergeListMutex); 
    639                     _pager->_dataToMergeList.push_back(databaseRequest); 
     650                    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_pager->_dataToMergeList->_requestMutex); 
     651                    databaseRequest->_requestQueue = _pager->_dataToMergeList.get(); 
     652                    _pager->_dataToMergeList->_requestList.push_back(databaseRequest); 
    640653                } 
    641654            }         
    …… 
    646659            if (loadedObjectsNeedToBeCompiled) 
    647660            { 
    648                 OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_pager->_dataToCompileListMutex); 
    649                 _pager->_dataToCompileList.sort(SortFileRequestFunctor()); 
     661                OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_pager->_dataToCompileList->_requestMutex); 
     662                _pager->_dataToCompileList->_requestList.sort(SortFileRequestFunctor()); 
    650663 
    651664                // Prune all the old entries. 
    652                 DatabaseRequestList::iterator tooOld 
    653                     = std::find_if(_pager->_dataToCompileList.begin(), 
    654                                    _pager->_dataToCompileList.end(), 
     665                RequestQueue::RequestList::iterator tooOld 
     666                    = std::find_if(_pager->_dataToCompileList->_requestList.begin(), 
     667                                   _pager->_dataToCompileList->_requestList.end(), 
    655668                                   refPtrAdapt(std::not1(std::bind2nd(std::mem_fun(&DatabaseRequest::isRequestCurrent), 
    656669                                   _pager->_frameNumber)))); 
    657670 
    658671                // This is the database thread, so just delete 
    659                 for(DatabaseRequestList::iterator citr = tooOld; 
    660                     citr != _pager->_dataToCompileList.end(); 
     672                for(RequestQueue::RequestList::iterator citr = tooOld; 
     673                    citr != _pager->_dataToCompileList->_requestList.end(); 
    661674                    ++citr) 
    662675                { 
    663676                    osg::notify(osg::INFO)<<_name<<": pruning from compile list"<<std::endl; 
    664677                    (*citr)->_loadedModel = 0; 
     678                    (*citr)->_requestQueue = 0; 
    665679                } 
    666680 
    667                 _pager->_dataToCompileList.erase(tooOld, _pager->_dataToCompileList.end()); 
    668  
    669                 loadedObjectsNeedToBeCompiled = !_pager->_dataToCompileList.empty(); 
     681                _pager->_dataToCompileList->_requestList.erase(tooOld, _pager->_dataToCompileList->_requestList.end()); 
     682 
     683                loadedObjectsNeedToBeCompiled = !_pager->_dataToCompileList->_requestList.empty(); 
    670684            } 
    671685 
    …… 
    846860        //osgDB::Registry::instance()->setUseObjectCacheHint(true); 
    847861         
    848     _fileRequestQueue = new RequestQueue(this,"fileRequestQueue"); 
    849     _httpRequestQueue = new RequestQueue(this,"httpRequestQueue"); 
     862    _fileRequestQueue = new ReadQueue(this,"fileRequestQueue"); 
     863    _httpRequestQueue = new ReadQueue(this,"httpRequestQueue"); 
     864     
     865    _dataToCompileList = new RequestQueue; 
     866    _dataToMergeList = new RequestQueue; 
     867     
    850868 
    851869#if 0 
    …… 
    894912    _maximumNumOfObjectsToCompilePerFrame = rhs._maximumNumOfObjectsToCompilePerFrame; 
    895913 
    896     _fileRequestQueue = new RequestQueue(this,"fileRequestQueue"); 
    897     _httpRequestQueue = new RequestQueue(this,"httpRequestQueue"); 
     914    _fileRequestQueue = new ReadQueue(this,"fileRequestQueue"); 
     915    _httpRequestQueue = new ReadQueue(this,"httpRequestQueue"); 
     916     
     917    _dataToCompileList = new RequestQueue; 
     918    _dataToMergeList = new RequestQueue; 
    898919 
    899920    for(DatabaseThreadList::const_iterator dt_itr = rhs._databaseThreads.begin(); 
    …… 
    9861007         
    9871008    { 
    988         OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileListMutex); 
    989         _dataToCompileList.clear(); 
    990     } 
    991  
    992     { 
    993         OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeListMutex); 
    994         _dataToMergeList.clear(); 
     1009        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileList->_requestMutex); 
     1010        for(RequestQueue::RequestList::iterator citr = _dataToCompileList->_requestList.begin(); 
     1011            citr != _dataToCompileList->_requestList.end(); 
     1012            ++citr) 
     1013        { 
     1014            (*citr)->_loadedModel = 0; 
     1015            (*citr)->_requestQueue = 0; 
     1016        } 
     1017        _dataToCompileList->_requestList.clear(); 
     1018    } 
     1019 
     1020    { 
     1021        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeList->_requestMutex); 
     1022        for(RequestQueue::RequestList::iterator citr = _dataToMergeList->_requestList.begin(); 
     1023            citr != _dataToMergeList->_requestList.end(); 
     1024            ++citr) 
     1025        { 
     1026            (*citr)->_loadedModel = 0; 
     1027            (*citr)->_requestQueue = 0; 
     1028        } 
     1029        _dataToMergeList->_requestList.clear(); 
    9951030    } 
    9961031 
    …… 
    10511086        if (databaseRequest) 
    10521087        { 
    1053             osg::notify(osg::INFO)<<"DatabasePager::fileRquest("<<fileName<<") updating alraedy assigned."<<std::endl; 
    1054  
    1055             databaseRequest->_frameNumberLastRequest = frameNumber; 
    1056             databaseRequest->_timestampLastRequest = timestamp; 
    1057             databaseRequest->_priorityLastRequest = priority; 
    1058             ++(databaseRequest->_numOfRequests); 
     1088            osg::notify(osg::INFO)<<"DatabasePager::fileRequest("<<fileName<<") updating alraedy assigned."<<std::endl; 
     1089 
     1090            RequestQueue* requestQueue = databaseRequest->_requestQueue; 
     1091            if (requestQueue) 
     1092            { 
     1093                OpenThreads::ScopedLock<OpenThreads::Mutex> lock(requestQueue->_requestMutex); 
     1094 
     1095                databaseRequest->_frameNumberLastRequest = frameNumber; 
     1096                databaseRequest->_timestampLastRequest = timestamp; 
     1097                databaseRequest->_priorityLastRequest = priority; 
     1098                ++(databaseRequest->_numOfRequests); 
     1099            } 
     1100            else 
     1101            { 
     1102                databaseRequest->_frameNumberLastRequest = frameNumber; 
     1103                databaseRequest->_timestampLastRequest = timestamp; 
     1104                databaseRequest->_priorityLastRequest = priority; 
     1105                ++(databaseRequest->_numOfRequests); 
     1106            } 
    10591107             
    10601108            foundEntry = true; 
    …… 
    10721120                databaseRequest->_groupForAddingLoadedSubgraph = group; 
    10731121                databaseRequest->_loadOptions = loadOptions; 
     1122                databaseRequest->_requestQueue = _fileRequestQueue.get(); 
    10741123 
    10751124                _fileRequestQueue->add(databaseRequest); 
    …… 
    11001149            databaseRequest->_groupForAddingLoadedSubgraph = group; 
    11011150            databaseRequest->_loadOptions = loadOptions; 
     1151            databaseRequest->_requestQueue = _fileRequestQueue.get(); 
    11021152 
    11031153            _fileRequestQueue->_requestList.push_back(databaseRequest.get()); 
    …… 
    11581208{ 
    11591209    { 
    1160         OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeListMutex); 
    1161         if (!_dataToMergeList.empty()) return true; 
     1210        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeList->_requestMutex); 
     1211        if (!_dataToMergeList->_requestList.empty()) return true; 
    11621212    } 
    11631213     
    …… 
    11721222    // osg::Timer_t before = osg::Timer::instance()->tick(); 
    11731223 
    1174     DatabaseRequestList localFileLoadedList; 
     1224    RequestQueue::RequestList localFileLoadedList; 
    11751225 
    11761226    // get the dat for the _dataToCompileList, leaving it empty via a std::vector<>.swap. 
    11771227    { 
    1178         OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeListMutex); 
    1179         localFileLoadedList.swap(_dataToMergeList); 
     1228        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeList->_requestMutex); 
     1229        localFileLoadedList.swap(_dataToMergeList->_requestList); 
    11801230    } 
    11811231         
    11821232    // add the loaded data into the scene graph. 
    1183     for(DatabaseRequestList::iterator itr=localFileLoadedList.begin(); 
     1233    for(RequestQueue::RequestList::iterator itr=localFileLoadedList.begin(); 
    11841234        itr!=localFileLoadedList.end(); 
    11851235        ++itr) 
    …… 
    13611411bool DatabasePager::requiresCompileGLObjects() const 
    13621412{ 
    1363     OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileListMutex); 
    1364     return !_dataToCompileList.empty(); 
     1413    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileList->_requestMutex); 
     1414    return !_dataToCompileList->_requestList.empty(); 
    13651415} 
    13661416 
    …… 
    14341484        // get the first compilable entry. 
    14351485        { 
    1436             OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileListMutex); 
     1486            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileList->_requestMutex); 
    14371487         
    14381488            // advance to the next entry to compile if one is available. 
    1439             databaseRequest = _dataToCompileList.empty() ? 0 : _dataToCompileList.front(); 
     1489            databaseRequest = _dataToCompileList->_requestList.empty() ? 0 : _dataToCompileList->_requestList.front(); 
    14401490        }; 
    14411491 
    …… 
    15541604 
    15551605 
    1556                 OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileListMutex); 
     1606                OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToCompileList->_requestMutex); 
    15571607 
    15581608                // The request might have been removed from the 
    …… 
    15641614                // not guaranteed to still be at the beginning of the 
    15651615                // list. 
    1566                 DatabaseRequestList::iterator requestIter 
    1567                     = std::find(_dataToCompileList.begin(), _dataToCompileList.end(), 
     1616                 
     1617                RequestQueue::RequestList::iterator requestIter 
     1618                    = std::find(_dataToCompileList->_requestList.begin(), _dataToCompileList->_requestList.end(), 
    15681619                           databaseRequest); 
    1569                 if (requestIter != _dataToCompileList.end()) 
     1620                if (requestIter != _dataToCompileList->_requestList.end()) 
    15701621                { 
    15711622                    { 
    1572                         OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeListMutex); 
    1573                         _dataToMergeList.push_back(databaseRequest); 
     1623                        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_dataToMergeList->_requestMutex); 
     1624                        databaseRequest->_requestQueue = _dataToMergeList.get(); 
     1625                        _dataToMergeList->_requestList.push_back(databaseRequest); 
    15741626                    } 
    1575                     _dataToCompileList.erase(requestIter); 
     1627                    _dataToCompileList->_requestList.erase(requestIter); 
    15761628                } 
    15771629                 
    1578                 if (!_dataToCompileList.empty()) databaseRequest = _dataToCompileList.front(); 
     1630                if (!_dataToCompileList->_requestList.empty()) databaseRequest = _dataToCompileList->_requestList.front(); 
    15791631                else databaseRequest = 0; 
    15801632