diff options
Diffstat (limited to 'src')
63 files changed, 407 insertions, 528 deletions
diff --git a/src/mongo/client/clientAndShell.cpp b/src/mongo/client/clientAndShell.cpp index 259ff72468a..e791d18d4b1 100644 --- a/src/mongo/client/clientAndShell.cpp +++ b/src/mongo/client/clientAndShell.cpp @@ -55,12 +55,12 @@ namespace mongo { // to avoid deadlocks at shutdown. So it also protects // the global dbexitCalled. namespace shell_utils { - mongo::mutex &mongoProgramOutputMutex(*(new mongo::mutex("mongoProgramOutputMutex"))); + mongo::mutex &mongoProgramOutputMutex(*(new boost::mutex())); } void dbexit( ExitCode returnCode, const char *whyMsg ) { { - mongo::mutex::scoped_lock lk( shell_utils::mongoProgramOutputMutex ); + boost::lock_guard<boost::mutex> lk( shell_utils::mongoProgramOutputMutex ); dbexitCalled = true; } log() << "dbexit called" << endl; diff --git a/src/mongo/client/clientOnly-private.h b/src/mongo/client/clientOnly-private.h index 6d4549218f4..763c82bb857 100644 --- a/src/mongo/client/clientOnly-private.h +++ b/src/mongo/client/clientOnly-private.h @@ -27,12 +27,10 @@ #pragma once -#include "mongo/client/export_macros.h" +#include <boost/thread/mutex.hpp> namespace mongo { - class mutex; - namespace shell_utils { - extern MONGO_CLIENT_API mongo::mutex &mongoProgramOutputMutex; + extern boost::mutex &mongoProgramOutputMutex; } } diff --git a/src/mongo/client/connpool.cpp b/src/mongo/client/connpool.cpp index 5cd702beaff..4b3002e1322 100644 --- a/src/mongo/client/connpool.cpp +++ b/src/mongo/client/connpool.cpp @@ -180,8 +180,7 @@ namespace mongo { const int PoolForHost::kPoolSizeUnlimited(-1); DBConnectionPool::DBConnectionPool() - : _mutex("DBConnectionPool") , - _name( "dbconnectionpool" ) , + : _name( "dbconnectionpool" ) , _maxPoolSize(PoolForHost::kPoolSizeUnlimited) , _hooks( new list<DBConnectionHook*>() ) { } @@ -189,7 +188,7 @@ namespace mongo { DBClientBase* DBConnectionPool::_get(const string& ident , double socketTimeout ) { uassert(17382, "Can't use connection pool during shutdown", !inShutdown()); - scoped_lock L(_mutex); + boost::lock_guard<boost::mutex> L(_mutex); PoolForHost& p = _pools[PoolKey(ident,socketTimeout)]; p.setMaxPoolSize(_maxPoolSize); p.initializeHostName(ident); @@ -198,7 +197,7 @@ namespace mongo { DBClientBase* DBConnectionPool::_finishCreate( const string& host , double socketTimeout , DBClientBase* conn ) { { - scoped_lock L(_mutex); + boost::lock_guard<boost::mutex> L(_mutex); PoolForHost& p = _pools[PoolKey(host,socketTimeout)]; p.setMaxPoolSize(_maxPoolSize); p.initializeHostName(host); @@ -273,7 +272,7 @@ namespace mongo { void DBConnectionPool::release(const string& host, DBClientBase *c) { onRelease(c); - scoped_lock L(_mutex); + boost::lock_guard<boost::mutex> L(_mutex); _pools[PoolKey(host,c->getSoTimeout())].done(this,c); } @@ -283,7 +282,7 @@ namespace mongo { } void DBConnectionPool::flush() { - scoped_lock L(_mutex); + boost::lock_guard<boost::mutex> L(_mutex); for ( PoolMap::iterator i = _pools.begin(); i != _pools.end(); i++ ) { PoolForHost& p = i->second; p.flush(); @@ -291,7 +290,7 @@ namespace mongo { } void DBConnectionPool::clear() { - scoped_lock L(_mutex); + boost::lock_guard<boost::mutex> L(_mutex); LOG(2) << "Removing connections on all pools owned by " << _name << endl; for (PoolMap::iterator iter = _pools.begin(); iter != _pools.end(); ++iter) { iter->second.clear(); @@ -299,7 +298,7 @@ namespace mongo { } void DBConnectionPool::removeHost( const string& host ) { - scoped_lock L(_mutex); + boost::lock_guard<boost::mutex> L(_mutex); LOG(2) << "Removing connections from all pools for host: " << host << endl; for ( PoolMap::iterator i = _pools.begin(); i != _pools.end(); ++i ) { const string& poolHost = i->first.ident; @@ -351,7 +350,7 @@ namespace mongo { BSONObjBuilder bb( b.subobjStart( "hosts" ) ); { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); for ( PoolMap::iterator i=_pools.begin(); i!=_pools.end(); ++i ) { if ( i->second.numCreated() == 0 ) continue; @@ -448,7 +447,7 @@ namespace mongo { } { - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); PoolForHost& pool = _pools[PoolKey(hostName, conn->getSoTimeout())]; if (pool.isBadSocketCreationTime(conn->getSockCreationMicroSec())) { return false; @@ -464,7 +463,7 @@ namespace mongo { { // we need to get the connections inside the lock // but we can actually delete them outside - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); for ( PoolMap::iterator i=_pools.begin(); i!=_pools.end(); ++i ) { i->second.getStaleConnections( toDelete ); } diff --git a/src/mongo/client/dbclient.cpp b/src/mongo/client/dbclient.cpp index be3d999a092..1018827dc8e 100644 --- a/src/mongo/client/dbclient.cpp +++ b/src/mongo/client/dbclient.cpp @@ -112,7 +112,7 @@ namespace mongo { _string = ss.str(); } - mutex ConnectionString::_connectHookMutex( "ConnectionString::_connectHook" ); + mutex ConnectionString::_connectHookMutex; ConnectionString::ConnectionHook* ConnectionString::_connectHook = NULL; DBClientBase* ConnectionString::connect( string& errmsg, double socketTimeout ) const { @@ -154,7 +154,7 @@ namespace mongo { case CUSTOM: { // Lock in case other things are modifying this at the same time - scoped_lock lk( _connectHookMutex ); + boost::lock_guard<boost::mutex> lk( _connectHookMutex ); // Allow the replacement of connections with other connections - useful for testing. diff --git a/src/mongo/client/dbclientinterface.h b/src/mongo/client/dbclientinterface.h index 4f63c21db92..2c2e9b86b3f 100644 --- a/src/mongo/client/dbclientinterface.h +++ b/src/mongo/client/dbclientinterface.h @@ -313,12 +313,12 @@ namespace mongo { }; static void setConnectionHook( ConnectionHook* hook ){ - scoped_lock lk( _connectHookMutex ); + boost::lock_guard<boost::mutex> lk( _connectHookMutex ); _connectHook = hook; } static ConnectionHook* getConnectionHook() { - scoped_lock lk( _connectHookMutex ); + boost::lock_guard<boost::mutex> lk( _connectHookMutex ); return _connectHook; } diff --git a/src/mongo/client/replica_set_monitor.cpp b/src/mongo/client/replica_set_monitor.cpp index 57de0e616d8..f3d25a97cb6 100644 --- a/src/mongo/client/replica_set_monitor.cpp +++ b/src/mongo/client/replica_set_monitor.cpp @@ -99,7 +99,7 @@ namespace { * SetState::mutex without holder setsLock, but then you can't grab setsLock until you * release the SetState::mutex. */ - mongo::mutex setsLock("ReplicaSetMonitor"); + mongo::mutex setsLock; StringMap<set<HostAndPort> > seedServers; StringMap<ReplicaSetMonitorPtr> sets; @@ -107,7 +107,6 @@ namespace { class ReplicaSetMonitorWatcher : public BackgroundJob { public: ReplicaSetMonitorWatcher(): - _monitorMutex("ReplicaSetMonitorWatcher::_safego"), _started(false), _stopRequested(false) { } @@ -126,7 +125,7 @@ namespace { virtual string name() const { return "ReplicaSetMonitorWatcher"; } void safeGo() { - scoped_lock lk( _monitorMutex ); + boost::lock_guard<boost::mutex> lk( _monitorMutex ); if ( _started ) return; @@ -140,7 +139,7 @@ namespace { * Stops monitoring the sets and wait for the monitoring thread to terminate. */ void stop() { - scoped_lock sl( _monitorMutex ); + boost::lock_guard<boost::mutex> sl( _monitorMutex ); _stopRequested = true; _stopRequestedCV.notify_one(); } @@ -154,14 +153,14 @@ namespace { // Should not be needed after SERVER-7533 gets implemented and tests start // using it. if (!inShutdown() && !StaticObserver::_destroyingStatics) { - scoped_lock sl( _monitorMutex ); - _stopRequestedCV.timed_wait(sl.boost(), boost::posix_time::seconds(10)); + boost::unique_lock<boost::mutex> sl( _monitorMutex ); + _stopRequestedCV.timed_wait(sl, boost::posix_time::seconds(10)); } while ( !inShutdown() && !StaticObserver::_destroyingStatics ) { { - scoped_lock sl( _monitorMutex ); + boost::lock_guard<boost::mutex> sl( _monitorMutex ); if (_stopRequested) { break; } @@ -177,12 +176,12 @@ namespace { error() << "unknown error"; } - scoped_lock sl( _monitorMutex ); + boost::unique_lock<boost::mutex> sl( _monitorMutex ); if (_stopRequested) { break; } - _stopRequestedCV.timed_wait(sl.boost(), boost::posix_time::seconds(10)); + _stopRequestedCV.timed_wait(sl, boost::posix_time::seconds(10)); } } @@ -190,7 +189,7 @@ namespace { // make a copy so we can quickly unlock setsLock StringMap<ReplicaSetMonitorPtr> setsCopy; { - scoped_lock lk( setsLock ); + boost::lock_guard<boost::mutex> lk( setsLock ); setsCopy = sets; } @@ -362,7 +361,7 @@ namespace { void ReplicaSetMonitor::createIfNeeded(const string& name, const set<HostAndPort>& servers) { LOG(3) << "ReplicaSetMonitor::createIfNeeded " << name; - scoped_lock lk(setsLock); + boost::lock_guard<boost::mutex> lk(setsLock); ReplicaSetMonitorPtr& m = sets[name]; if ( ! m ) m = boost::make_shared<ReplicaSetMonitor>( name , servers ); @@ -373,7 +372,7 @@ namespace { ReplicaSetMonitorPtr ReplicaSetMonitor::get(const std::string& name, const bool createFromSeed) { LOG(3) << "ReplicaSetMonitor::get " << name; - scoped_lock lk( setsLock ); + boost::lock_guard<boost::mutex> lk( setsLock ); StringMap<ReplicaSetMonitorPtr>::const_iterator i = sets.find( name ); if ( i != sets.end() ) { return i->second; @@ -394,7 +393,7 @@ namespace { set<string> ReplicaSetMonitor::getAllTrackedSets() { set<string> activeSets; - scoped_lock lk( setsLock ); + boost::lock_guard<boost::mutex> lk( setsLock ); for (StringMap<ReplicaSetMonitorPtr>::const_iterator it = sets.begin(); it != sets.end(); ++it) { @@ -407,7 +406,7 @@ namespace { LOG(2) << "Removing ReplicaSetMonitor for " << name << " from replica set table" << (clearSeedCache ? " and the seed cache" : ""); - scoped_lock lk( setsLock ); + boost::lock_guard<boost::mutex> lk( setsLock ); const StringMap<ReplicaSetMonitorPtr>::const_iterator setIt = sets.find(name); if (setIt != sets.end()) { if (!clearSeedCache) { @@ -474,7 +473,7 @@ namespace { replicaSetMonitorWatcher.cancel(); replicaSetMonitorWatcher.stop(); replicaSetMonitorWatcher.wait(); - scoped_lock lock(setsLock); + boost::lock_guard<boost::mutex> lock(setsLock); sets = StringMap<ReplicaSetMonitorPtr>(); seedServers = StringMap<set<HostAndPort> >(); } diff --git a/src/mongo/client/scoped_db_conn_test.cpp b/src/mongo/client/scoped_db_conn_test.cpp index b6ce00e0717..600b54d2908 100644 --- a/src/mongo/client/scoped_db_conn_test.cpp +++ b/src/mongo/client/scoped_db_conn_test.cpp @@ -62,7 +62,7 @@ namespace { const string TARGET_HOST = "localhost:27017"; const int TARGET_PORT = 27017; - mongo::mutex shutDownMutex("shutDownMutex"); + mongo::mutex shutDownMutex; bool shuttingDown = false; } @@ -73,7 +73,7 @@ namespace mongo { // Symbols defined to build the binary correctly. bool inShutdown() { - scoped_lock sl(shutDownMutex); + boost::lock_guard<boost::mutex> sl(shutDownMutex); return shuttingDown; } @@ -81,7 +81,7 @@ namespace mongo { void dbexit(ExitCode rc, const char *why){ { - scoped_lock sl(shutDownMutex); + boost::lock_guard<boost::mutex> sl(shutDownMutex); shuttingDown = true; } @@ -157,7 +157,7 @@ namespace mongo_test { options.port = _port; { - mongo::mutex::scoped_lock sl(shutDownMutex); + boost::lock_guard<boost::mutex> sl(shutDownMutex); shuttingDown = false; } @@ -174,7 +174,7 @@ namespace mongo_test { } { - mongo::mutex::scoped_lock sl(shutDownMutex); + boost::lock_guard<boost::mutex> sl(shutDownMutex); shuttingDown = true; } diff --git a/src/mongo/client/syncclusterconnection.cpp b/src/mongo/client/syncclusterconnection.cpp index 762a2d69ea0..29f184f3689 100644 --- a/src/mongo/client/syncclusterconnection.cpp +++ b/src/mongo/client/syncclusterconnection.cpp @@ -52,7 +52,9 @@ namespace mongo { using std::stringstream; using std::vector; - SyncClusterConnection::SyncClusterConnection( const list<HostAndPort> & L, double socketTimeout) : _mutex("SyncClusterConnection"), _socketTimeout( socketTimeout ) { + SyncClusterConnection::SyncClusterConnection( const list<HostAndPort> & L, double socketTimeout) + : _socketTimeout(socketTimeout) { + { stringstream s; int n=0; @@ -66,7 +68,9 @@ namespace mongo { _connect( i->toString() ); } - SyncClusterConnection::SyncClusterConnection( string commaSeparated, double socketTimeout) : _mutex("SyncClusterConnection"), _socketTimeout( socketTimeout ) { + SyncClusterConnection::SyncClusterConnection( string commaSeparated, double socketTimeout) : + _socketTimeout( socketTimeout ) { + _address = commaSeparated; string::size_type idx; while ( ( idx = commaSeparated.find( ',' ) ) != string::npos ) { @@ -78,7 +82,12 @@ namespace mongo { uassert( 8004 , "SyncClusterConnection needs 3 servers" , _conns.size() == 3 ); } - SyncClusterConnection::SyncClusterConnection( const std::string& a , const std::string& b , const std::string& c, double socketTimeout) : _mutex("SyncClusterConnection"), _socketTimeout( socketTimeout ) { + SyncClusterConnection::SyncClusterConnection( + const std::string& a, + const std::string& b, + const std::string& c, + double socketTimeout) : _socketTimeout( socketTimeout ) { + _address = a + "," + b + "," + c; // connect to all even if not working _connect( a ); @@ -86,7 +95,8 @@ namespace mongo { _connect( c ); } - SyncClusterConnection::SyncClusterConnection( SyncClusterConnection& prev, double socketTimeout) : _mutex("SyncClusterConnection"), _socketTimeout( socketTimeout ) { + SyncClusterConnection::SyncClusterConnection( SyncClusterConnection& prev, double socketTimeout) + : _socketTimeout(socketTimeout) { verify(0); } @@ -530,7 +540,7 @@ namespace mongo { int SyncClusterConnection::_lockType( const string& name ) { { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); map<string,int>::iterator i = _lockTypes.find( name ); if ( i != _lockTypes.end() ) return i->second; @@ -541,7 +551,7 @@ namespace mongo { int lockType = info["lockType"].numberInt(); - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); _lockTypes[name] = lockType; return lockType; } diff --git a/src/mongo/db/commands/dbhash.cpp b/src/mongo/db/commands/dbhash.cpp index 9d42024210d..bf0f43dcc9b 100644 --- a/src/mongo/db/commands/dbhash.cpp +++ b/src/mongo/db/commands/dbhash.cpp @@ -62,9 +62,7 @@ namespace mongo { // ---- - DBHashCmd::DBHashCmd() - : Command( "dbHash", false, "dbhash" ), - _cachedHashedMutex( "_cachedHashedMutex" ){ + DBHashCmd::DBHashCmd() : Command("dbHash", false, "dbhash") { } void DBHashCmd::addRequiredPrivileges(const std::string& dbname, @@ -75,11 +73,14 @@ namespace mongo { out->push_back(Privilege(ResourcePattern::forDatabaseName(dbname), actions)); } - string DBHashCmd::hashCollection( OperationContext* opCtx, Database* db, const string& fullCollectionName, bool* fromCache ) { - scoped_ptr<scoped_lock> cachedHashedLock; + std::string DBHashCmd::hashCollection(OperationContext* opCtx, + Database* db, + const std::string& fullCollectionName, + bool* fromCache) { + boost::unique_lock<boost::mutex> cachedHashedLock(_cachedHashedMutex, boost::defer_lock); if ( isCachable( fullCollectionName ) ) { - cachedHashedLock.reset( new scoped_lock( _cachedHashedMutex ) ); + cachedHashedLock.lock(); string hash = _cachedHashed[fullCollectionName]; if ( hash.size() > 0 ) { *fromCache = true; @@ -133,7 +134,7 @@ namespace mongo { md5_finish(&st, d); string hash = digestToString( d ); - if ( cachedHashedLock.get() ) { + if (cachedHashedLock.owns_lock()) { _cachedHashed[fullCollectionName] = hash; } @@ -225,7 +226,7 @@ namespace mongo { } void commit() { - scoped_lock lk( _dCmd->_cachedHashedMutex ); + boost::lock_guard<boost::mutex> lk( _dCmd->_cachedHashedMutex ); _dCmd->_cachedHashed.erase(_ns); } void rollback() { } diff --git a/src/mongo/db/global_optime.cpp b/src/mongo/db/global_optime.cpp index e47c5f0f40d..664838a179c 100644 --- a/src/mongo/db/global_optime.cpp +++ b/src/mongo/db/global_optime.cpp @@ -33,7 +33,7 @@ #include "mongo/util/log.h" namespace { - mongo::mutex globalOptimeMutex("globalOptime"); + mongo::mutex globalOptimeMutex; mongo::OpTime globalOpTime(0, 0); bool skewed(const mongo::OpTime& val) { @@ -49,17 +49,17 @@ namespace { namespace mongo { void setGlobalOptime(const OpTime& newTime) { - mutex::scoped_lock lk(globalOptimeMutex); + boost::lock_guard<boost::mutex> lk(globalOptimeMutex); globalOpTime = newTime; } OpTime getLastSetOptime() { - mutex::scoped_lock lk(globalOptimeMutex); + boost::lock_guard<boost::mutex> lk(globalOptimeMutex); return globalOpTime; } OpTime getNextGlobalOptime() { - mutex::scoped_lock lk(globalOptimeMutex); + boost::lock_guard<boost::mutex> lk(globalOptimeMutex); const unsigned now = (unsigned) time(0); const unsigned globalSecs = globalOpTime.getSecs(); diff --git a/src/mongo/db/instance.cpp b/src/mongo/db/instance.cpp index aa1cf74a859..cdb1ee82116 100644 --- a/src/mongo/db/instance.cpp +++ b/src/mongo/db/instance.cpp @@ -1186,8 +1186,7 @@ namespace mongo { } // ----- BEGIN Diaglog ----- - DiagLog::DiagLog() : f(0) , level(0), mutex("DiagLog") { - } + DiagLog::DiagLog() : f(0), level(0) {} void DiagLog::openFile() { verify( f == 0 ); @@ -1206,7 +1205,7 @@ namespace mongo { } int DiagLog::setLevel( int newLevel ) { - scoped_lock lk(mutex); + boost::lock_guard<boost::mutex> lk(mutex); int old = level; log() << "diagLogging level=" << newLevel << endl; if( f == 0 ) { @@ -1219,14 +1218,14 @@ namespace mongo { void DiagLog::flush() { if ( level ) { log() << "flushing diag log" << endl; - scoped_lock lk(mutex); + boost::lock_guard<boost::mutex> lk(mutex); f->flush(); } } void DiagLog::writeop(char *data,int len) { if ( level & 1 ) { - scoped_lock lk(mutex); + boost::lock_guard<boost::mutex> lk(mutex); f->write(data,len); } } @@ -1236,7 +1235,7 @@ namespace mongo { bool log = (level & 4) == 0; OCCASIONALLY log = true; if ( log ) { - scoped_lock lk(mutex); + boost::lock_guard<boost::mutex> lk(mutex); verify( f ); f->write(data,len); } diff --git a/src/mongo/db/range_deleter.cpp b/src/mongo/db/range_deleter.cpp index 232cdc1e57d..8d14aef3a98 100644 --- a/src/mongo/db/range_deleter.cpp +++ b/src/mongo/db/range_deleter.cpp @@ -158,11 +158,8 @@ namespace mongo { RangeDeleter::RangeDeleter(RangeDeleterEnv* env): _env(env), // ownership xfer - _stopMutex("stopRangeDeleter"), _stopRequested(false), - _queueMutex("RangeDeleter"), - _deletesInProgress(0), - _statsHistoryMutex("RangeDeleterStatsHistory") { + _deletesInProgress(0) { } RangeDeleter::~RangeDeleter() { @@ -200,7 +197,7 @@ namespace mongo { void RangeDeleter::stopWorkers() { { - scoped_lock sl(_stopMutex); + boost::lock_guard<boost::mutex> sl(_stopMutex); _stopRequested = true; } @@ -208,9 +205,9 @@ namespace mongo { _worker->join(); } - scoped_lock sl(_queueMutex); + boost::unique_lock<boost::mutex> sl(_queueMutex); while (_deletesInProgress > 0) { - _nothingInProgressCV.wait(sl.boost()); + _nothingInProgressCV.wait(sl); } } @@ -230,7 +227,7 @@ namespace mongo { toDelete->notifyDone = notifyDone; { - scoped_lock sl(_queueMutex); + boost::lock_guard<boost::mutex> sl(_queueMutex); if (_stopRequested) { *errMsg = "deleter is already stopped."; return false; @@ -253,7 +250,7 @@ namespace mongo { logCursorsWaiting(toDelete.get()); { - scoped_lock sl(_queueMutex); + boost::lock_guard<boost::mutex> sl(_queueMutex); if (toDelete->cursorsToWait.empty()) { toDelete->stats.queueEndTS = jsTime(); @@ -320,7 +317,7 @@ namespace { NSMinMax deleteRange(ns, min, max); { - scoped_lock sl(_queueMutex); + boost::lock_guard<boost::mutex> sl(_queueMutex); if (!canEnqueue_inlock(ns, min, max, errMsg)) { return false; } @@ -362,7 +359,7 @@ namespace { if (stopRequested()) { *errMsg = "deleter was stopped."; - scoped_lock sl(_queueMutex); + boost::lock_guard<boost::mutex> sl(_queueMutex); _deleteSet.erase(&deleteRange); _deletesInProgress--; @@ -395,7 +392,7 @@ namespace { } { - scoped_lock sl(_queueMutex); + boost::lock_guard<boost::mutex> sl(_queueMutex); _deleteSet.erase(&deleteRange); _deletesInProgress--; @@ -413,7 +410,7 @@ namespace { stats->clear(); stats->reserve(kDeleteJobsHistory); - scoped_lock sl(_statsHistoryMutex); + boost::lock_guard<boost::mutex> sl(_statsHistoryMutex); for (std::deque<DeleteJobStats*>::const_iterator it = _statsHistory.begin(); it != _statsHistory.end(); ++it) { stats->push_back(new DeleteJobStats(**it)); @@ -421,7 +418,7 @@ namespace { } BSONObj RangeDeleter::toBSON() const { - scoped_lock sl(_queueMutex); + boost::lock_guard<boost::mutex> sl(_queueMutex); BSONObjBuilder builder; @@ -453,10 +450,10 @@ namespace { RangeDeleteEntry* nextTask = NULL; { - scoped_lock sl(_queueMutex); + boost::unique_lock<boost::mutex> sl(_queueMutex); while (_taskQueue.empty()) { _taskQueueNotEmptyCV.timed_wait( - sl.boost(), duration::milliseconds(kNotEmptyTimeoutMillis)); + sl, duration::milliseconds(kNotEmptyTimeoutMillis)); if (stopRequested()) { log() << "stopping range deleter worker" << endl; @@ -539,7 +536,7 @@ namespace { } { - scoped_lock sl(_queueMutex); + boost::lock_guard<boost::mutex> sl(_queueMutex); NSMinMax setEntry(nextTask->options.range.ns, nextTask->options.range.minKey, @@ -574,27 +571,27 @@ namespace { } bool RangeDeleter::stopRequested() const { - scoped_lock sl(_stopMutex); + boost::lock_guard<boost::mutex> sl(_stopMutex); return _stopRequested; } size_t RangeDeleter::getTotalDeletes() const { - scoped_lock sl(_queueMutex); + boost::lock_guard<boost::mutex> sl(_queueMutex); return _deleteSet.size(); } size_t RangeDeleter::getPendingDeletes() const { - scoped_lock sl(_queueMutex); + boost::lock_guard<boost::mutex> sl(_queueMutex); return _notReadyQueue.size() + _taskQueue.size(); } size_t RangeDeleter::getDeletesInProgress() const { - scoped_lock sl(_queueMutex); + boost::lock_guard<boost::mutex> sl(_queueMutex); return _deletesInProgress; } void RangeDeleter::recordDelStats(DeleteJobStats* newStat) { - scoped_lock sl(_statsHistoryMutex); + boost::lock_guard<boost::mutex> sl(_statsHistoryMutex); if (_statsHistory.size() == kDeleteJobsHistory) { delete _statsHistory.front(); _statsHistory.pop_front(); diff --git a/src/mongo/db/range_deleter_mock_env.cpp b/src/mongo/db/range_deleter_mock_env.cpp index 0a56f1bcb7d..7bff0c9dcc8 100644 --- a/src/mongo/db/range_deleter_mock_env.cpp +++ b/src/mongo/db/range_deleter_mock_env.cpp @@ -52,59 +52,55 @@ namespace mongo { } RangeDeleterMockEnv::RangeDeleterMockEnv(): - _deleteListMutex("delList"), - _cursorMapMutex("cursorMap"), - _pauseDeleteMutex("pauseDelete"), _pauseDelete(false), _pausedCount(0), - _envStatMutex("envStat"), _getCursorsCallCount(0) { setGlobalEnvironment(new GlobalEnvironmentNoop()); } void RangeDeleterMockEnv::addCursorId(StringData ns, CursorId id) { - scoped_lock sl(_cursorMapMutex); + boost::lock_guard<boost::mutex> sl(_cursorMapMutex); _cursorMap[ns.toString()].insert(id); } void RangeDeleterMockEnv::removeCursorId(StringData ns, CursorId id) { - scoped_lock sl(_cursorMapMutex); + boost::lock_guard<boost::mutex> sl(_cursorMapMutex); _cursorMap[ns.toString()].erase(id); } void RangeDeleterMockEnv::pauseDeletes() { - scoped_lock sl(_pauseDeleteMutex); + boost::lock_guard<boost::mutex> sl(_pauseDeleteMutex); _pauseDelete = true; } void RangeDeleterMockEnv::resumeOneDelete() { - scoped_lock sl(_pauseDeleteMutex); + boost::lock_guard<boost::mutex> sl(_pauseDeleteMutex); _pauseDelete = false; _pausedCV.notify_one(); } void RangeDeleterMockEnv::waitForNthGetCursor(uint64_t nthCall) { - scoped_lock sl(_envStatMutex); + boost::unique_lock<boost::mutex> sl(_envStatMutex); while (_getCursorsCallCount < nthCall) { - _cursorsCallCountUpdatedCV.wait(sl.boost()); + _cursorsCallCountUpdatedCV.wait(sl); } } void RangeDeleterMockEnv::waitForNthPausedDelete(uint64_t nthPause) { - scoped_lock sl(_pauseDeleteMutex); + boost::unique_lock<boost::mutex> sl(_pauseDeleteMutex); while(_pausedCount < nthPause) { - _pausedDeleteChangeCV.wait(sl.boost()); + _pausedDeleteChangeCV.wait(sl); } } bool RangeDeleterMockEnv::deleteOccured() const { - scoped_lock sl(_deleteListMutex); + boost::lock_guard<boost::mutex> sl(_deleteListMutex); return !_deleteList.empty(); } DeletedRange RangeDeleterMockEnv::getLastDelete() const { - scoped_lock sl(_deleteListMutex); + boost::lock_guard<boost::mutex> sl(_deleteListMutex); return _deleteList.back(); } @@ -114,7 +110,7 @@ namespace mongo { string* errMsg) { { - scoped_lock sl(_pauseDeleteMutex); + boost::unique_lock<boost::mutex> sl(_pauseDeleteMutex); bool wasInitiallyPaused = _pauseDelete; if (_pauseDelete) { @@ -123,14 +119,14 @@ namespace mongo { } while (_pauseDelete) { - _pausedCV.wait(sl.boost()); + _pausedCV.wait(sl); } _pauseDelete = wasInitiallyPaused; } { - scoped_lock sl(_deleteListMutex); + boost::lock_guard<boost::mutex> sl(_deleteListMutex); DeletedRange entry; entry.ns = taskDetails.options.range.ns; @@ -147,13 +143,13 @@ namespace mongo { void RangeDeleterMockEnv::getCursorIds( OperationContext* txn, StringData ns, set<CursorId>* in) { { - scoped_lock sl(_cursorMapMutex); + boost::lock_guard<boost::mutex> sl(_cursorMapMutex); const set<CursorId>& _cursors = _cursorMap[ns.toString()]; std::copy(_cursors.begin(), _cursors.end(), inserter(*in, in->begin())); } { - scoped_lock sl(_envStatMutex); + boost::lock_guard<boost::mutex> sl(_envStatMutex); _getCursorsCallCount++; _cursorsCallCountUpdatedCV.notify_one(); } diff --git a/src/mongo/db/repl/oplog.cpp b/src/mongo/db/repl/oplog.cpp index 76ba3f7ec20..7d4eace3154 100644 --- a/src/mongo/db/repl/oplog.cpp +++ b/src/mongo/db/repl/oplog.cpp @@ -91,7 +91,7 @@ namespace { // Synchronizes the section where a new OpTime is generated and when it actually // appears in the oplog. - mongo::mutex newOpMutex("oplogNewOp"); + mongo::mutex newOpMutex; boost::condition newOptimeNotifier; static std::string _oplogCollectionName; @@ -118,7 +118,7 @@ namespace { const char* ns, ReplicationCoordinator* replCoord, const char* opstr) { - mutex::scoped_lock lk(newOpMutex); + boost::lock_guard<boost::mutex> lk(newOpMutex); OpTime ts = getNextGlobalOptime(); newOptimeNotifier.notify_all(); @@ -665,17 +665,17 @@ namespace { } void waitUpToOneSecondForOptimeChange(const OpTime& referenceTime) { - mutex::scoped_lock lk(newOpMutex); + boost::unique_lock<boost::mutex> lk(newOpMutex); while (referenceTime == getLastSetOptime()) { - if (!newOptimeNotifier.timed_wait(lk.boost(), + if (!newOptimeNotifier.timed_wait(lk, boost::posix_time::seconds(1))) return; } } void setNewOptime(const OpTime& newTime) { - mutex::scoped_lock lk(newOpMutex); + boost::lock_guard<boost::mutex> lk(newOpMutex); setGlobalOptime(newTime); newOptimeNotifier.notify_all(); } diff --git a/src/mongo/db/stats/snapshots.cpp b/src/mongo/db/stats/snapshots.cpp index b44ef9812f6..ccae800a0f5 100644 --- a/src/mongo/db/stats/snapshots.cpp +++ b/src/mongo/db/stats/snapshots.cpp @@ -73,14 +73,14 @@ namespace mongo { } Snapshots::Snapshots(int n) - : _lock("Snapshots"), _n(n) + : _n(n) , _snapshots(new SnapshotData[n]) , _loc(0) , _stored(0) {} const SnapshotData* Snapshots::takeSnapshot() { - scoped_lock lk(_lock); + boost::lock_guard<boost::mutex> lk(_lock); _loc = ( _loc + 1 ) % _n; _snapshots[_loc].takeSnapshot(); if ( _stored < _n ) @@ -89,7 +89,7 @@ namespace mongo { } auto_ptr<SnapshotDelta> Snapshots::computeDelta( int numBack ) { - scoped_lock lk(_lock); + boost::lock_guard<boost::mutex> lk(_lock); auto_ptr<SnapshotDelta> p; if ( numBack < numDeltas() ) p.reset( new SnapshotDelta( getPrev(numBack+1) , getPrev(numBack) ) ); diff --git a/src/mongo/db/storage/mmap_v1/dur_journal.cpp b/src/mongo/db/storage/mmap_v1/dur_journal.cpp index 4dd2a39e39f..369ed9a4075 100644 --- a/src/mongo/db/storage/mmap_v1/dur_journal.cpp +++ b/src/mongo/db/storage/mmap_v1/dur_journal.cpp @@ -159,9 +159,9 @@ namespace mongo { namespace { SecureRandom* mySecureRandom = NULL; - mongo::mutex mySecureRandomMutex( "JHeader-SecureRandom" ); + mongo::mutex mySecureRandomMutex; int64_t getMySecureRandomNumber() { - scoped_lock lk( mySecureRandomMutex ); + boost::lock_guard<boost::mutex> lk( mySecureRandomMutex ); if ( ! mySecureRandom ) mySecureRandom = SecureRandom::create(); return mySecureRandom->nextInt64(); diff --git a/src/mongo/db/storage/mmap_v1/dur_preplogbuffer.cpp b/src/mongo/db/storage/mmap_v1/dur_preplogbuffer.cpp index 6c2021b37b1..1a0d03d96a4 100644 --- a/src/mongo/db/storage/mmap_v1/dur_preplogbuffer.cpp +++ b/src/mongo/db/storage/mmap_v1/dur_preplogbuffer.cpp @@ -136,7 +136,7 @@ namespace mongo { (although not assured) that it is journaled here once. */ static void prepBasicWrites(AlignedBuilder& bb, const std::vector<WriteIntent>& intents) { - scoped_lock lk(privateViews._mutex()); + boost::lock_guard<boost::mutex> lk(privateViews._mutex()); // Each time write intents switch to a different database we journal a JDbContext. // Switches will be rare as we sort by memory location first and we batch commit. diff --git a/src/mongo/db/storage/mmap_v1/dur_recover.cpp b/src/mongo/db/storage/mmap_v1/dur_recover.cpp index 4ca797afc89..9297472057b 100644 --- a/src/mongo/db/storage/mmap_v1/dur_recover.cpp +++ b/src/mongo/db/storage/mmap_v1/dur_recover.cpp @@ -253,8 +253,7 @@ namespace mongo { RecoveryJob::RecoveryJob() - : _mx("recovery"), - _recovering(false), + : _recovering(false), _lastDataSyncedFromLastRun(0), _lastSeqMentionedInConsoleLog(1) { @@ -268,7 +267,7 @@ namespace mongo { } void RecoveryJob::close() { - scoped_lock lk(_mx); + boost::lock_guard<boost::mutex> lk(_mx); _close(); } @@ -388,7 +387,7 @@ namespace mongo { void RecoveryJob::processSection(const JSectHeader *h, const void *p, unsigned len, const JSectFooter *f) { LockMongoFilesShared lkFiles; // for RecoveryJob::Last - scoped_lock lk(_mx); + boost::lock_guard<boost::mutex> lk(_mx); // Check the footer checksum before doing anything else. if (_recovering) { diff --git a/src/mongo/db/storage/mmap_v1/durable_mapped_file.cpp b/src/mongo/db/storage/mmap_v1/durable_mapped_file.cpp index 3a2d2b2db9a..197cb45e844 100644 --- a/src/mongo/db/storage/mmap_v1/durable_mapped_file.cpp +++ b/src/mongo/db/storage/mmap_v1/durable_mapped_file.cpp @@ -85,7 +85,7 @@ namespace mongo { /** de-register view. threadsafe */ void PointerToDurableMappedFile::remove(void *view, size_t len) { if( view ) { - mutex::scoped_lock lk(_m); + boost::lock_guard<boost::mutex> lk(_m); clearWritableBits_inlock(view, len); _views.erase(view); } @@ -93,7 +93,7 @@ namespace mongo { #ifdef _WIN32 void PointerToDurableMappedFile::clearWritableBits(void *privateView, size_t len) { - mutex::scoped_lock lk(_m); + boost::lock_guard<boost::mutex> lk(_m); clearWritableBits_inlock(privateView, len); } @@ -110,7 +110,7 @@ namespace mongo { extern mutex mapViewMutex; __declspec(noinline) void PointerToDurableMappedFile::makeChunkWritable(size_t chunkno) { - mutex::scoped_lock lkPrivateViews(_m); + boost::lock_guard<boost::mutex> lkPrivateViews(_m); if (writable.get(chunkno)) // double check lock return; @@ -120,7 +120,7 @@ namespace mongo { size_t chunkStart = chunkno * MemoryMappedCOWBitset::ChunkSize; size_t chunkNext = chunkStart + MemoryMappedCOWBitset::ChunkSize; - scoped_lock lkMapView(mapViewMutex); + boost::lock_guard<boost::mutex> lkMapView(mapViewMutex); map<void*, DurableMappedFile*>::iterator i = _views.upper_bound((void*)(chunkNext - 1)); while (1) { @@ -182,7 +182,7 @@ namespace mongo { } #endif - PointerToDurableMappedFile::PointerToDurableMappedFile() : _m("PointerToDurableMappedFile") { + PointerToDurableMappedFile::PointerToDurableMappedFile() { #if defined(SIZE_MAX) size_t max = SIZE_MAX; #else @@ -225,7 +225,7 @@ namespace mongo { @return the DurableMappedFile to which this pointer belongs. null if not found. */ DurableMappedFile* PointerToDurableMappedFile::find(void *p, /*out*/ size_t& ofs) { - mutex::scoped_lock lk(_m); + boost::lock_guard<boost::mutex> lk(_m); return find_inlock(p, ofs); } @@ -267,7 +267,7 @@ namespace mongo { LOG(3) << "mmf finishOpening " << (void*) _view_write << ' ' << filename() << " len:" << length(); if( _view_write ) { if (storageGlobalParams.dur) { - scoped_lock lk2(privateViews._mutex()); + boost::lock_guard<boost::mutex> lk2(privateViews._mutex()); _view_private = createPrivateMap(); if( _view_private == 0 ) { diff --git a/src/mongo/db/storage/mmap_v1/mmap_v1_extent_manager.cpp b/src/mongo/db/storage/mmap_v1/mmap_v1_extent_manager.cpp index b6dda97e3eb..cb481ec9835 100644 --- a/src/mongo/db/storage/mmap_v1/mmap_v1_extent_manager.cpp +++ b/src/mongo/db/storage/mmap_v1/mmap_v1_extent_manager.cpp @@ -657,7 +657,7 @@ namespace mongo { } void MmapV1ExtentManager::FilesArray::push_back(DataFile* val) { - scoped_lock lk(_writersMutex); + boost::lock_guard<boost::mutex> lk(_writersMutex); const int n = _size.load(); invariant(n < DiskLoc::MaxFiles); // Note ordering: _size update must come after updating the _files array diff --git a/src/mongo/db/storage/mmap_v1/mmap_v1_extent_manager.h b/src/mongo/db/storage/mmap_v1/mmap_v1_extent_manager.h index dadc17b0a1f..323386fdd56 100644 --- a/src/mongo/db/storage/mmap_v1/mmap_v1_extent_manager.h +++ b/src/mongo/db/storage/mmap_v1/mmap_v1_extent_manager.h @@ -208,7 +208,7 @@ namespace mongo { */ class FilesArray { public: - FilesArray() : _writersMutex("MmapV1ExtentManager"), _size(0) { } + FilesArray() : _size(0) { } ~FilesArray(); /** diff --git a/src/mongo/dbtests/documentsourcetests.cpp b/src/mongo/dbtests/documentsourcetests.cpp index a0e98367238..ad812a971d0 100644 --- a/src/mongo/dbtests/documentsourcetests.cpp +++ b/src/mongo/dbtests/documentsourcetests.cpp @@ -284,19 +284,16 @@ namespace DocumentSourceTests { /** Set a value or await an expected value. */ class PendingValue { public: - PendingValue( int initialValue ) : - _value( initialValue ), - _mutex( "DocumentSourceTests::PendingValue::_mutex" ) { - } + PendingValue( int initialValue ) : _value( initialValue ) {} void set( int newValue ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _value = newValue; _condition.notify_all(); } void await( int expectedValue ) const { - scoped_lock lk( _mutex ); + boost::unique_lock<boost::mutex> lk( _mutex ); while( _value != expectedValue ) { - _condition.wait( lk.boost() ); + _condition.wait( lk ); } } private: diff --git a/src/mongo/dbtests/framework.cpp b/src/mongo/dbtests/framework.cpp index d8b1bb9c472..2b859fc8c2c 100644 --- a/src/mongo/dbtests/framework.cpp +++ b/src/mongo/dbtests/framework.cpp @@ -63,7 +63,7 @@ namespace mongo { namespace dbtests { - mutex globalCurrentTestNameMutex("globalCurrentTestNameMutex"); + mutex globalCurrentTestNameMutex; std::string globalCurrentTestName; class TestWatchDog : public BackgroundJob { @@ -75,7 +75,7 @@ namespace mongo { std::string lastRunningTestName, currentTestName; { - scoped_lock lk( globalCurrentTestNameMutex ); + boost::lock_guard<boost::mutex> lk( globalCurrentTestNameMutex ); lastRunningTestName = globalCurrentTestName; } @@ -84,7 +84,7 @@ namespace mongo { minutesRunning++; { - scoped_lock lk( globalCurrentTestNameMutex ); + boost::lock_guard<boost::mutex> lk( globalCurrentTestNameMutex ); currentTestName = globalCurrentTestName; } @@ -138,6 +138,6 @@ namespace mongo { } // namespace mongo void mongo::unittest::onCurrentTestNameChange( const std::string &testName ) { - scoped_lock lk( mongo::dbtests::globalCurrentTestNameMutex ); + boost::lock_guard<boost::mutex> lk( mongo::dbtests::globalCurrentTestNameMutex ); mongo::dbtests::globalCurrentTestName = testName; } diff --git a/src/mongo/dbtests/mock/mock_conn_registry.cpp b/src/mongo/dbtests/mock/mock_conn_registry.cpp index c50e177667f..92f1382c542 100644 --- a/src/mongo/dbtests/mock/mock_conn_registry.cpp +++ b/src/mongo/dbtests/mock/mock_conn_registry.cpp @@ -46,10 +46,7 @@ namespace mongo { return Status::OK(); } - MockConnRegistry::MockConnRegistry(): - _mockConnStrHook(this), - _registryMutex("mockConnRegistryMutex") { - } + MockConnRegistry::MockConnRegistry() : _mockConnStrHook(this) {} MockConnRegistry* MockConnRegistry::get() { return _instance.get(); @@ -60,7 +57,7 @@ namespace mongo { } void MockConnRegistry::addServer(MockRemoteDBServer* server) { - scoped_lock sl(_registryMutex); + boost::lock_guard<boost::mutex> sl(_registryMutex); const std::string hostName(server->getServerAddress()); fassert(16533, _registry.count(hostName) == 0); @@ -69,17 +66,17 @@ namespace mongo { } bool MockConnRegistry::removeServer(const std::string& hostName) { - scoped_lock sl(_registryMutex); + boost::lock_guard<boost::mutex> sl(_registryMutex); return _registry.erase(hostName) == 1; } void MockConnRegistry::clear() { - scoped_lock sl(_registryMutex); + boost::lock_guard<boost::mutex> sl(_registryMutex); _registry.clear(); } MockDBClientConnection* MockConnRegistry::connect(const std::string& connStr) { - scoped_lock sl(_registryMutex); + boost::lock_guard<boost::mutex> sl(_registryMutex); fassert(16534, _registry.count(connStr) == 1); return new MockDBClientConnection(_registry[connStr], true); } diff --git a/src/mongo/dbtests/perftests.cpp b/src/mongo/dbtests/perftests.cpp index 76ae98c56d3..38dfc814d8e 100644 --- a/src/mongo/dbtests/perftests.cpp +++ b/src/mongo/dbtests/perftests.cpp @@ -537,7 +537,6 @@ namespace PerfTests { RWLock lk("testrw"); SimpleMutex m("simptst"); - mongo::mutex mtest("mtest"); boost::mutex mboost; boost::timed_mutex mboost_timed; std::mutex mstd; @@ -554,15 +553,6 @@ namespace PerfTests { c.notify_one(); } }; - class mutexspeed : public B { - public: - string name() { return "mutex"; } - virtual int howLongMillis() { return 500; } - virtual bool showDurStats() { return false; } - void timed() { - mongo::mutex::scoped_lock lk(mtest); - } - }; class boostmutexspeed : public B { public: string name() { return "boost::mutex"; } @@ -1474,7 +1464,6 @@ namespace PerfTests { add< locker_contestedS >(); add< locker_uncontestedS >(); add< NotifyOne >(); - add< mutexspeed >(); add< simplemutexspeed >(); add< boostmutexspeed >(); add< boosttimed_mutexspeed >(); diff --git a/src/mongo/dbtests/threadedtests.cpp b/src/mongo/dbtests/threadedtests.cpp index 62d8465e940..8085be0534e 100644 --- a/src/mongo/dbtests/threadedtests.cpp +++ b/src/mongo/dbtests/threadedtests.cpp @@ -754,17 +754,17 @@ namespace ThreadedTests { class Hotel { public: - Hotel( int nRooms ) : _frontDesk( "frontDesk" ), _nRooms( nRooms ), _checkedIn( 0 ), _maxRooms( 0 ) {} + Hotel( int nRooms ) : _nRooms( nRooms ), _checkedIn( 0 ), _maxRooms( 0 ) {} void checkIn(){ - scoped_lock lk( _frontDesk ); + boost::lock_guard<boost::mutex> lk( _frontDesk ); _checkedIn++; verify( _checkedIn <= _nRooms ); if( _checkedIn > _maxRooms ) _maxRooms = _checkedIn; } void checkOut(){ - scoped_lock lk( _frontDesk ); + boost::lock_guard<boost::mutex> lk( _frontDesk ); _checkedIn--; verify( _checkedIn >= 0 ); } @@ -824,7 +824,6 @@ namespace ThreadedTests { // Slack is a test to see how long it takes for another thread to pick up // and begin work after another relinquishes the lock. e.g. a spin lock // would have very little slack. - add< Slack<mongo::mutex , mongo::mutex::scoped_lock > >(); add< Slack<SimpleMutex,SimpleMutex::scoped_lock> >(); add< Slack<SimpleRWLock,SimpleRWLock::Exclusive> >(); add< CondSlack >(); diff --git a/src/mongo/logger/ramlog.cpp b/src/mongo/logger/ramlog.cpp index 36ac1ef5023..0ea9e324d96 100644 --- a/src/mongo/logger/ramlog.cpp +++ b/src/mongo/logger/ramlog.cpp @@ -206,10 +206,10 @@ namespace { RamLog* RamLog::get(const std::string& name) { if (!_namedLock) { // Guaranteed to happen before multi-threaded operation. - _namedLock = new mongo::mutex("RamLog::_namedLock"); + _namedLock = new mongo::mutex(); } - scoped_lock lk( *_namedLock ); + boost::lock_guard<boost::mutex> lk( *_namedLock ); if (!_named) { // Guaranteed to happen before multi-threaded operation. _named = new RM(); @@ -226,7 +226,7 @@ namespace { RamLog* RamLog::getIfExists(const std::string& name) { if (!_named) return NULL; - scoped_lock lk(*_namedLock); + boost::lock_guard<boost::mutex> lk(*_namedLock); return mapFindWithDefault(*_named, name, static_cast<RamLog*>(NULL)); } @@ -234,7 +234,7 @@ namespace { if ( ! _named ) return; - scoped_lock lk( *_namedLock ); + boost::lock_guard<boost::mutex> lk( *_namedLock ); for ( RM::iterator i=_named->begin(); i!=_named->end(); ++i ) { if ( i->second->n ) names.push_back( i->first ); @@ -251,7 +251,7 @@ namespace { return Status(ErrorCodes::InternalError, "Inconsistent intiailization of RamLogCatalog."); } - _namedLock = new mongo::mutex("RamLog::_namedLock"); + _namedLock = new mongo::mutex(); _named = new RM(); } diff --git a/src/mongo/s/chunk_manager.cpp b/src/mongo/s/chunk_manager.cpp index 0270fbe2ba6..6e3dfe60309 100644 --- a/src/mongo/s/chunk_manager.cpp +++ b/src/mongo/s/chunk_manager.cpp @@ -116,7 +116,6 @@ namespace { _keyPattern( pattern.getKeyPattern() ), _unique( unique ), _chunkRanges(), - _mutex("ChunkManager"), _sequenceNumber(NextSequenceNumber.addAndFetch(1)) { // @@ -135,7 +134,6 @@ namespace { BSONObj()), _unique(collDoc[CollectionType::unique()].trueValue()), _chunkRanges(), - _mutex("ChunkManager"), // The shard versioning mechanism hinges on keeping track of the number of times we reloaded ChunkManager's. // Increasing this number here will prompt checkShardVersion() to refresh the connection-level versions to // the most up to date value. @@ -663,7 +661,7 @@ namespace { } void ChunkManager::drop() const { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk(_mutex); configServer.logChange( "dropCollection.start" , _ns , BSONObj() ); diff --git a/src/mongo/s/client/shard_connection.cpp b/src/mongo/s/client/shard_connection.cpp index c1357835bd2..69b17ea6656 100644 --- a/src/mongo/s/client/shard_connection.cpp +++ b/src/mongo/s/client/shard_connection.cpp @@ -65,17 +65,13 @@ namespace { */ class ActiveClientConnections { public: - ActiveClientConnections() : _mutex("ActiveClientConnections") { - - } - void add(const ClientConnections* cc) { - scoped_lock lock(_mutex); + boost::lock_guard<boost::mutex> lock(_mutex); _clientConnections.insert(cc); } void remove(const ClientConnections* cc) { - scoped_lock lock(_mutex); + boost::lock_guard<boost::mutex> lock(_mutex); _clientConnections.erase(cc); } @@ -391,7 +387,7 @@ namespace { BSONArrayBuilder arr(64 * 1024); // There may be quite a few threads { - scoped_lock lock(_mutex); + boost::lock_guard<boost::mutex> lock(_mutex); for (set<const ClientConnections*>::const_iterator i = _clientConnections.begin(); i != _clientConnections.end(); ++i) { diff --git a/src/mongo/s/config.cpp b/src/mongo/s/config.cpp index d279fa06475..2cad43ca841 100644 --- a/src/mongo/s/config.cpp +++ b/src/mongo/s/config.cpp @@ -164,10 +164,7 @@ namespace mongo { DBConfig::DBConfig(std::string name) : _name(name), _primary("config", "", 0 /* maxSize */, false /* draining */), - _shardingEnabled(false), - _lock("DBConfig"), - _hitConfigServerLock("DBConfig::_hitConfigServerLock") { - + _shardingEnabled(false) { invariant(!_name.empty()); } @@ -178,7 +175,7 @@ namespace mongo { bool DBConfig::isSharded( const string& ns ) { if ( ! _shardingEnabled ) return false; - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); return _isSharded( ns ); } @@ -221,7 +218,7 @@ namespace mongo { verify( _name != "config" ); - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); _shardingEnabled = true; if( save ) _save(); } @@ -241,7 +238,7 @@ namespace mongo { ChunkManagerPtr manager; { - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); CollectionInfo& ci = _collections[ns]; uassert( 8043 , "collection already sharded" , ! ci.isSharded() ); @@ -321,7 +318,7 @@ namespace mongo { return false; } - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); CollectionInfoMap::iterator i = _collections.find( ns ); @@ -352,7 +349,7 @@ namespace mongo { primary.reset(); { - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); CollectionInfoMap::iterator i = _collections.find( ns ); @@ -403,7 +400,7 @@ namespace mongo { ChunkManagerPtr oldManager; { - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); bool earlyReload = ! _collections[ns].isSharded() && ( shouldReload || forceReload ); if ( earlyReload ) { @@ -441,7 +438,7 @@ namespace mongo { if ( ! newest.isEmpty() ) { ChunkVersion v = ChunkVersion::fromBSON(newest, ChunkType::DEPRECATED_lastmod()); if ( v.equals( oldVersion ) ) { - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); CollectionInfo& ci = _collections[ns]; uassert( 15885 , str::stream() << "not sharded after reloading from chunks : " << ns , ci.isSharded() ); return ci.getCM(); @@ -459,13 +456,13 @@ namespace mongo { auto_ptr<ChunkManager> temp; { - scoped_lock lll ( _hitConfigServerLock ); + boost::lock_guard<boost::mutex> lll ( _hitConfigServerLock ); if ( ! newest.isEmpty() && ! forceReload ) { // if we have a target we're going for // see if we've hit already - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); CollectionInfo& ci = _collections[ns]; if ( ci.isSharded() && ci.getCM() ) { @@ -495,7 +492,7 @@ namespace mongo { } } - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); CollectionInfo& ci = _collections[ns]; uassert( 14822 , (string)"state changed in the middle: " + ns , ci.isSharded() ); @@ -535,7 +532,7 @@ namespace mongo { } void DBConfig::setPrimary( const std::string& s ) { - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); _primary.reset( s ); _save(); } @@ -562,7 +559,7 @@ namespace mongo { } bool DBConfig::load() { - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); return _load(); } @@ -660,7 +657,7 @@ namespace mongo { bool successful = false; { - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); successful = _reload(); } @@ -798,7 +795,7 @@ namespace mongo { } void DBConfig::getAllShards(set<Shard>& shards) const { - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); shards.insert(getPrimary()); for (CollectionInfoMap::const_iterator it(_collections.begin()), end(_collections.end()); it != end; ++it) { if (it->second.isSharded()) { @@ -809,7 +806,7 @@ namespace mongo { void DBConfig::getAllShardedCollections( set<string>& namespaces ) const { - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); for( CollectionInfoMap::const_iterator i = _collections.begin(); i != _collections.end(); i++ ) { log() << "Coll : " << i->first << " sharded? " << i->second.isSharded() << endl; diff --git a/src/mongo/s/config_server_checker_service.cpp b/src/mongo/s/config_server_checker_service.cpp index 6f80a7004a1..92ac1062faf 100644 --- a/src/mongo/s/config_server_checker_service.cpp +++ b/src/mongo/s/config_server_checker_service.cpp @@ -45,7 +45,7 @@ namespace mongo { boost::scoped_ptr<boost::thread> _checkerThread; // Protects _isConsistentFromLastCheck. - mutex _isConsistentMutex( "ConfigServerConsistent" ); + mutex _isConsistentMutex; bool _isConsistentFromLastCheck = true; void checkConfigConsistency() { @@ -53,7 +53,7 @@ namespace mongo { bool isConsistent = configServer.ok( true ); { - scoped_lock sl( _isConsistentMutex ); + boost::lock_guard<boost::mutex> sl( _isConsistentMutex ); _isConsistentFromLastCheck = isConsistent; } @@ -63,7 +63,7 @@ namespace mongo { } bool isConfigServerConsistent() { - scoped_lock sl( _isConsistentMutex ); + boost::lock_guard<boost::mutex> sl( _isConsistentMutex ); return _isConsistentFromLastCheck; } diff --git a/src/mongo/s/cursors.cpp b/src/mongo/s/cursors.cpp index 3fd45ecaa0e..75875d7177d 100644 --- a/src/mongo/s/cursors.cpp +++ b/src/mongo/s/cursors.cpp @@ -226,9 +226,8 @@ namespace mongo { } CursorCache::CursorCache() - :_mutex( "CursorCache" ), - _random( getCCRandomSeed() ), - _shardedTotal(0) { + : _random( getCCRandomSeed() ), + _shardedTotal(0) { } CursorCache::~CursorCache() { @@ -247,7 +246,7 @@ namespace mongo { ShardedClientCursorPtr CursorCache::get( long long id ) const { LOG(_myLogLevel) << "CursorCache::get id: " << id << endl; - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); MapSharded::const_iterator i = _cursors.find( id ); if ( i == _cursors.end() ) { return ShardedClientCursorPtr(); @@ -258,7 +257,7 @@ namespace mongo { int CursorCache::getMaxTimeMS( long long id ) const { verify( id ); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); MapShardedInt::const_iterator i = _cursorsMaxTimeMS.find( id ); return ( i != _cursorsMaxTimeMS.end() ) ? i->second : 0; } @@ -272,7 +271,7 @@ namespace mongo { verify( maxTimeMS == kMaxTimeCursorTimeLimitExpired || maxTimeMS == kMaxTimeCursorNoTimeLimit || maxTimeMS > 0 ); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _cursorsMaxTimeMS[cursor->getId()] = maxTimeMS; _cursors[cursor->getId()] = cursor; _shardedTotal++; @@ -283,20 +282,20 @@ namespace mongo { verify( maxTimeMS == kMaxTimeCursorTimeLimitExpired || maxTimeMS == kMaxTimeCursorNoTimeLimit || maxTimeMS > 0 ); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _cursorsMaxTimeMS[id] = maxTimeMS; } void CursorCache::remove( long long id ) { verify( id ); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _cursorsMaxTimeMS.erase( id ); _cursors.erase( id ); } void CursorCache::removeRef( long long id ) { verify( id ); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _refs.erase( id ); _refsNS.erase( id ); cursorStatsSingleTarget.decrement(); @@ -305,7 +304,7 @@ namespace mongo { void CursorCache::storeRef(const std::string& server, long long id, const std::string& ns) { LOG(_myLogLevel) << "CursorCache::storeRef server: " << server << " id: " << id << endl; verify( id ); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _refs[id] = server; _refsNS[id] = ns; cursorStatsSingleTarget.increment(); @@ -313,7 +312,7 @@ namespace mongo { string CursorCache::getRef( long long id ) const { verify( id ); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); MapNormal::const_iterator i = _refs.find( id ); LOG(_myLogLevel) << "CursorCache::getRef id: " << id << " out: " << ( i == _refs.end() ? " NONE " : i->second ) << endl; @@ -325,7 +324,7 @@ namespace mongo { std::string CursorCache::getRefNS(long long id) const { verify(id); - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); MapNormal::const_iterator i = _refsNS.find(id); LOG(_myLogLevel) << "CursorCache::getRefNs id: " << id @@ -339,7 +338,7 @@ namespace mongo { long long CursorCache::genId() { while ( true ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); long long x = Listener::getElapsedTimeMillis() << 32; x |= _random.nextInt32(); @@ -391,7 +390,7 @@ namespace mongo { string server; { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); MapSharded::iterator i = _cursors.find( id ); if ( i != _cursors.end() ) { @@ -442,7 +441,7 @@ namespace mongo { } void CursorCache::appendInfo( BSONObjBuilder& result ) const { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); result.append( "sharded", static_cast<int>(cursorStatsMultiTarget.get())); result.appendNumber( "shardedEver" , _shardedTotal ); result.append( "refs", static_cast<int>(cursorStatsSingleTarget.get())); @@ -451,7 +450,7 @@ namespace mongo { void CursorCache::doTimeouts() { long long now = Listener::getElapsedTimeMillis(); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); for ( MapSharded::iterator i=_cursors.begin(); i!=_cursors.end(); ++i ) { // Note: cursors with no timeout will always have an idleTime of 0 long long idleFor = i->second->idleTime( now ); diff --git a/src/mongo/s/d_migrate.cpp b/src/mongo/s/d_migrate.cpp index 64486cc827d..72f1740ca8c 100644 --- a/src/mongo/s/d_migrate.cpp +++ b/src/mongo/s/d_migrate.cpp @@ -253,11 +253,9 @@ namespace mongo { class MigrateFromStatus { public: MigrateFromStatus(): - _mutex("MigrateFromStatus"), _inCriticalSection(false), _memoryUsed(0), - _active(false), - _cloneLocsMutex("MigrateFromTrackerMutex") { + _active(false) { } /** @@ -276,7 +274,7 @@ namespace mongo { // Get global shared to synchronize with logOp. Also see comments in the class // members declaration for more details. Lock::GlobalRead globalShared(txn->lockState()); - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); if (_active) { return false; @@ -293,7 +291,7 @@ namespace mongo { _active = true; - scoped_lock tLock(_cloneLocsMutex); + boost::lock_guard<boost::mutex> tLock(_cloneLocsMutex); verify(_cloneLocs.size() == 0); return true; @@ -306,7 +304,7 @@ namespace mongo { // Get global shared to synchronize with logOp. Also see comments in the class // members declaration for more details. Lock::GlobalRead globalShared(txn->lockState()); - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); _active = false; _deleteNotifyExec.reset( NULL ); @@ -317,7 +315,7 @@ namespace mongo { _reload.clear(); _memoryUsed = 0; - scoped_lock cloneLock(_cloneLocsMutex); + boost::lock_guard<boost::mutex> cloneLock(_cloneLocsMutex); _cloneLocs.clear(); } @@ -443,7 +441,7 @@ namespace mongo { { AutoGetCollectionForRead ctx(txn, getNS()); - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); if (!_active) { errmsg = "no active migration!"; return false; @@ -502,7 +500,7 @@ namespace mongo { // It's alright not to lock _mutex all the way through based on the assumption // that this is only called by the main thread that drives the migration and // only it can start and stop the current migration. - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); invariant( _deleteNotifyExec.get() == NULL ); WorkingSet* ws = new WorkingSet(); @@ -552,7 +550,7 @@ namespace mongo { RecordId dl; while (PlanExecutor::ADVANCED == exec->getNext(NULL, &dl)) { if ( ! isLargeChunk ) { - scoped_lock lk(_cloneLocsMutex); + boost::lock_guard<boost::mutex> lk(_cloneLocsMutex); _cloneLocs.insert( dl ); } @@ -565,7 +563,7 @@ namespace mongo { exec.reset(); if ( isLargeChunk ) { - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); warning() << "cannot move chunk: the maximum number of documents for a chunk is " << maxRecsWhenFull << " , the maximum chunk size is " << maxChunkSize << " , average document size is " << avgRecSize @@ -593,7 +591,7 @@ namespace mongo { { AutoGetCollectionForRead ctx(txn, getNS()); - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); if (!_active) { errmsg = "not active"; return false; @@ -616,7 +614,7 @@ namespace mongo { while (!isBufferFilled) { AutoGetCollectionForRead ctx(txn, getNS()); - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); if (!_active) { errmsg = "not active"; return false; @@ -631,7 +629,7 @@ namespace mongo { return false; } - scoped_lock lk(_cloneLocsMutex); + boost::lock_guard<boost::mutex> lk(_cloneLocsMutex); set<RecordId>::iterator cloneLocsIter = _cloneLocs.begin(); for ( ; cloneLocsIter != _cloneLocs.end(); ++cloneLocsIter) { if (tracker.intervalHasElapsed()) // should I yield? @@ -674,33 +672,33 @@ namespace mongo { // that check only works for non-mmapv1 engines, and this is needed // for mmapv1. - scoped_lock lk(_cloneLocsMutex); + boost::lock_guard<boost::mutex> lk(_cloneLocsMutex); _cloneLocs.erase( dl ); } std::size_t cloneLocsRemaining() { - scoped_lock lk(_cloneLocsMutex); + boost::lock_guard<boost::mutex> lk(_cloneLocsMutex); return _cloneLocs.size(); } long long mbUsed() const { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); return _memoryUsed / ( 1024 * 1024 ); } bool getInCriticalSection() const { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); return _inCriticalSection; } void setInCriticalSection( bool b ) { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); _inCriticalSection = b; _inCriticalSectionCV.notify_all(); } std::string getNS() const { - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); return _ns; } @@ -712,9 +710,9 @@ namespace mongo { boost::xtime_get(&xt, MONGO_BOOST_TIME_UTC); xt.sec += maxSecondsToWait; - scoped_lock lk(_mutex); + boost::unique_lock<boost::mutex> lk(_mutex); while (_inCriticalSection) { - if (!_inCriticalSectionCV.timed_wait(lk.boost(), xt)) + if (!_inCriticalSectionCV.timed_wait(lk, xt)) return false; } @@ -724,8 +722,8 @@ namespace mongo { bool isActive() const { return _getActive(); } private: - bool _getActive() const { scoped_lock lk(_mutex); return _active; } - void _setActive( bool b ) { scoped_lock lk(_mutex); _active = b; } + bool _getActive() const { boost::lock_guard<boost::mutex> lk(_mutex); return _active; } + void _setActive( bool b ) { boost::lock_guard<boost::mutex> lk(_mutex); _active = b; } /** * Used to commit work for LogOpForSharding. Used to keep track of changes in documents @@ -748,7 +746,7 @@ namespace mongo { virtual void commit() { switch (_op) { case 'd': { - scoped_lock sl(_migrateFromStatus->_mutex); + boost::lock_guard<boost::mutex> sl(_migrateFromStatus->_mutex); _migrateFromStatus->_deleted.push_back(_idObj); _migrateFromStatus->_memoryUsed += _idObj.firstElement().size() + 5; break; @@ -757,7 +755,7 @@ namespace mongo { case 'i': case 'u': { - scoped_lock sl(_migrateFromStatus->_mutex); + boost::lock_guard<boost::mutex> sl(_migrateFromStatus->_mutex); _migrateFromStatus->_reload.push_back(_idObj); _migrateFromStatus->_memoryUsed += _idObj.firstElement().size() + 5; break; @@ -1818,7 +1816,6 @@ namespace mongo { }; MigrateStatus(): - _mutex("MigrateStatus"), _active(false), _numCloned(0), _clonedBytes(0), @@ -1828,12 +1825,12 @@ namespace mongo { } void setState(State newState) { - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); _state = newState; } State getState() const { - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); return _state; } @@ -1845,7 +1842,7 @@ namespace mongo { const BSONObj& min, const BSONObj& max, const BSONObj& shardKeyPattern) { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); if (_active) { return Status(ErrorCodes::ConflictingOperationInProgress, @@ -1888,7 +1885,7 @@ namespace mongo { } catch ( std::exception& e ) { { - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); _state = FAIL; _errmsg = e.what(); } @@ -1897,7 +1894,7 @@ namespace mongo { } catch ( ... ) { { - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); _state = FAIL; _errmsg = "UNKNOWN ERROR"; } @@ -2182,7 +2179,7 @@ namespace mongo { thisTime++; { - scoped_lock statsLock(_mutex); + boost::lock_guard<boost::mutex> statsLock(_mutex); _numCloned++; _clonedBytes += docToClone.objsize(); } @@ -2354,7 +2351,7 @@ namespace mongo { } void status(BSONObjBuilder& b) { - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); b.appendBool("active", _active); @@ -2569,7 +2566,7 @@ namespace mongo { } bool startCommit() { - scoped_lock lock(_mutex); + boost::unique_lock<boost::mutex> lock(_mutex); if (_state != STEADY) { return false; @@ -2581,7 +2578,7 @@ namespace mongo { _state = COMMIT_START; while (_active) { - if ( ! isActiveCV.timed_wait( lock.boost(), xt ) ){ + if ( ! isActiveCV.timed_wait( lock, xt ) ){ // TIMEOUT _state = FAIL; log() << "startCommit never finished!" << migrateLog; @@ -2598,14 +2595,14 @@ namespace mongo { } void abort() { - scoped_lock sl(_mutex); + boost::lock_guard<boost::mutex> sl(_mutex); _state = ABORT; _errmsg = "aborted"; } - bool getActive() const { scoped_lock lk(_mutex); return _active; } + bool getActive() const { boost::lock_guard<boost::mutex> lk(_mutex); return _active; } void setActive( bool b ) { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); _active = b; isActiveCV.notify_all(); } diff --git a/src/mongo/s/d_state.cpp b/src/mongo/s/d_state.cpp index 15b2ef6ec9f..c89d7532755 100644 --- a/src/mongo/s/d_state.cpp +++ b/src/mongo/s/d_state.cpp @@ -76,12 +76,12 @@ namespace mongo { // -----ShardingState START ---- ShardingState::ShardingState() - : _enabled(false) , _mutex( "ShardingState" ), + : _enabled(false), _configServerTickets( 3 /* max number of concurrent config server refresh threads */ ) { } void ShardingState::enable( const string& server ) { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); _enabled = true; verify( server.size() ); @@ -108,7 +108,7 @@ namespace mongo { } bool ShardingState::setShardNameAndHost( const string& name, const string& host ) { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); if ( _shardName.size() == 0 ) { // TODO SERVER-2299 remotely verify the name is sound w.r.t IPs _shardName = name; @@ -156,7 +156,7 @@ namespace mongo { } void ShardingState::resetShardingState() { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); _enabled = false; _configServer.clear(); @@ -166,14 +166,14 @@ namespace mongo { // TODO we shouldn't need three ways for checking the version. Fix this. bool ShardingState::hasVersion( const string& ns ) { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); CollectionMetadataMap::const_iterator it = _collMetadata.find(ns); return it != _collMetadata.end(); } bool ShardingState::hasVersion( const string& ns , ChunkVersion& version ) { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); CollectionMetadataMap::const_iterator it = _collMetadata.find(ns); if ( it == _collMetadata.end() ) @@ -185,7 +185,7 @@ namespace mongo { } const ChunkVersion ShardingState::getVersion( const string& ns ) const { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); CollectionMetadataMap::const_iterator it = _collMetadata.find( ns ); if ( it != _collMetadata.end() ) { @@ -204,7 +204,7 @@ namespace mongo { ChunkVersion version) { invariant(txn->lockState()->isCollectionLockedForMode(ns, MODE_X)); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); CollectionMetadataMap::const_iterator it = _collMetadata.find( ns ); verify( it != _collMetadata.end() ) ; @@ -234,7 +234,7 @@ namespace mongo { CollectionMetadataPtr prevMetadata) { invariant(txn->lockState()->isCollectionLockedForMode(ns, MODE_X)); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); log() << "ShardingState::undoDonateChunk acquired _mutex" << endl; @@ -251,7 +251,7 @@ namespace mongo { string* errMsg ) { invariant(txn->lockState()->isCollectionLockedForMode(ns, MODE_X)); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); CollectionMetadataMap::const_iterator it = _collMetadata.find( ns ); if ( it == _collMetadata.end() ) { @@ -296,7 +296,7 @@ namespace mongo { string* errMsg ) { invariant(txn->lockState()->isCollectionLockedForMode(ns, MODE_X)); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); CollectionMetadataMap::const_iterator it = _collMetadata.find( ns ); if ( it == _collMetadata.end() ) { @@ -341,7 +341,7 @@ namespace mongo { ChunkVersion version ) { invariant(txn->lockState()->isCollectionLockedForMode(ns, MODE_X)); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); CollectionMetadataMap::const_iterator it = _collMetadata.find( ns ); verify( it != _collMetadata.end() ) ; @@ -365,7 +365,7 @@ namespace mongo { ChunkVersion mergedVersion ) { invariant(txn->lockState()->isCollectionLockedForMode(ns, MODE_X)); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); CollectionMetadataMap::const_iterator it = _collMetadata.find( ns ); verify( it != _collMetadata.end() ); @@ -383,7 +383,7 @@ namespace mongo { } void ShardingState::resetMetadata( const string& ns ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); warning() << "resetting metadata for " << ns << ", this should only be used in testing" << endl; @@ -417,7 +417,7 @@ namespace mongo { CollectionMetadataPtr storedMetadata; { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); CollectionMetadataMap::iterator it = _collMetadata.find( ns ); if ( it != _collMetadata.end() ) storedMetadata = it->second; } @@ -483,7 +483,7 @@ namespace mongo { string configServer; { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); // We can't reload if sharding is not enabled - i.e. without a config server location if (!_enabled) { @@ -608,7 +608,7 @@ namespace mongo { // Get the metadata now that the load has completed // - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); // Don't reload if our config server has changed or sharding is no longer enabled if (!_enabled) { @@ -785,7 +785,7 @@ namespace mongo { void ShardingState::appendInfo(BSONObjBuilder& builder) { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); builder.appendBool("enabled", _enabled); if (!_enabled) @@ -814,7 +814,7 @@ namespace mongo { } CollectionMetadataPtr ShardingState::getCollectionMetadata( const string& ns ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); CollectionMetadataMap::const_iterator it = _collMetadata.find( ns ); if ( it == _collMetadata.end() ) { @@ -866,10 +866,10 @@ namespace mongo { } void ShardedConnectionInfo::addHook() { - static mongo::mutex lock("ShardedConnectionInfo::addHook mutex"); + static mongo::mutex lock; static bool done = false; - scoped_lock lk(lock); + boost::lock_guard<boost::mutex> lk(lock); if (!done) { log() << "first cluster operation detected, adding sharding hook to enable versioning " "and authentication to remote servers" << endl; diff --git a/src/mongo/s/d_state.h b/src/mongo/s/d_state.h index d9edb1159b9..34368b0c143 100644 --- a/src/mongo/s/d_state.h +++ b/src/mongo/s/d_state.h @@ -60,7 +60,7 @@ namespace mongo { void gotShardName( const std::string& name ); bool setShardName( const std::string& name ); // Same as above, does not throw - std::string getShardName() { scoped_lock lk(_mutex); return _shardName; } + std::string getShardName() { boost::lock_guard<boost::mutex> lk(_mutex); return _shardName; } // Helpers for SetShardVersion which report the host name sent to this shard when the shard // name does not match. Do not use in other places. diff --git a/src/mongo/s/distlock.cpp b/src/mongo/s/distlock.cpp index 651811f3ef6..7ae4749c092 100644 --- a/src/mongo/s/distlock.cpp +++ b/src/mongo/s/distlock.cpp @@ -108,11 +108,6 @@ namespace mongo { class DistributedLockPinger { public: - - DistributedLockPinger() - : _mutex( "DistributedLockPinger" ) { - } - void _distLockPingThread( ConnectionString addr, const std::string& process, unsigned long long sleepTime ) { @@ -213,7 +208,7 @@ namespace mongo { // Remove old locks, if possible // Make sure no one else is adding to this list at the same time - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); int numOldLocks = _oldLockOIDs.size(); if( numOldLocks > 0 ) { @@ -294,7 +289,7 @@ namespace mongo { if (!lockPingerEnabled) return ""; // Make sure we don't start multiple threads for a process id - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); const ConnectionString& conn = lock.getRemoteConnection(); const string& processId = lock.getProcessId(); @@ -320,18 +315,18 @@ namespace mongo { void addUnlockOID( const OID& oid ) { // Modifying the lock from some other thread - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _oldLockOIDs.push_back( oid ); } bool willUnlockOID( const OID& oid ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); return find( _oldLockOIDs.begin(), _oldLockOIDs.end(), oid ) != _oldLockOIDs.end(); } void kill( const ConnectionString& conn, const string& processId ) { // Make sure we're in a consistent state before other threads can see us - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); string pingId = pingThreadId( conn, processId ); @@ -341,13 +336,13 @@ namespace mongo { } bool shouldKill( const ConnectionString& conn, const string& processId ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); return _kill.count( pingThreadId( conn, processId ) ) > 0; } void finishKill( const ConnectionString& conn, const string& processId ) { // Make sure we're in a consistent state before other threads can see us - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); string pingId = pingThreadId( conn, processId ); @@ -374,7 +369,7 @@ namespace mongo { _processId( asProcess ? getDistLockId() : getDistLockProcess() ), _lockTimeout( lockTimeout == 0 ? LOCK_TIMEOUT : lockTimeout ), _maxClockSkew( _lockTimeout / LOCK_SKEW_FACTOR ), _maxNetSkew( _maxClockSkew ), - _lockPing( _maxClockSkew ), _mutex( "DistributedLock" ) + _lockPing( _maxClockSkew ) { LOG( logLvl ) << "created new distributed lock for " << name << " on " << conn << " ( lock timeout : " << _lockTimeout @@ -384,12 +379,12 @@ namespace mongo { } DistributedLock::PingData DistributedLock::LastPings::getLastPing( const ConnectionString& conn, const string& lockName ){ - scoped_lock lock( _mutex ); + boost::lock_guard<boost::mutex> lock( _mutex ); return _lastPings[ std::pair< string, string >( conn.toString(), lockName ) ]; } void DistributedLock::LastPings::setLastPing( const ConnectionString& conn, const string& lockName, const PingData& pd ){ - scoped_lock lock( _mutex ); + boost::lock_guard<boost::mutex> lock( _mutex ); _lastPings[ std::pair< string, string >( conn.toString(), lockName ) ] = pd; } @@ -613,7 +608,7 @@ namespace mongo { // TODO: Start pinging only when we actually get the lock? // If we don't have a thread pinger, make sure we shouldn't have one if( _threadId == "" ){ - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _threadId = distLockPinger.got( *this, _lockPing ); } diff --git a/src/mongo/s/distlock.h b/src/mongo/s/distlock.h index 4ce30222068..1b52039129c 100644 --- a/src/mongo/s/distlock.h +++ b/src/mongo/s/distlock.h @@ -127,9 +127,6 @@ namespace mongo { class LastPings { public: - LastPings() : _mutex( "DistributedLock::LastPings" ) {} - ~LastPings(){} - PingData getLastPing( const ConnectionString& conn, const std::string& lockName ); void setLastPing( const ConnectionString& conn, const std::string& lockName, const PingData& pd ); @@ -137,7 +134,7 @@ namespace mongo { std::map< std::pair<std::string, std::string>, PingData > _lastPings; }; - static LastPings lastPings; + static LastPings lastPings; /** * The constructor does not connect to the configdb yet and constructing does not mean the lock was acquired. diff --git a/src/mongo/s/grid.cpp b/src/mongo/s/grid.cpp index 60874a05c57..7e10b231c60 100644 --- a/src/mongo/s/grid.cpp +++ b/src/mongo/s/grid.cpp @@ -67,15 +67,7 @@ namespace mongo { MONGO_FP_DECLARE(neverBalance); - Grid::Grid() - : _lock("Grid"), - _allowLocalShard(true) { - - } - - Grid::~Grid() { - - } + Grid::Grid() : _allowLocalShard(true) {} DBConfigPtr Grid::getDBConfig( StringData ns , bool create , const string& shardNameHint ) { string database = nsToDatabase( ns ); @@ -87,7 +79,7 @@ namespace mongo { str::stream() << "invalid database name: " << database, NamespaceString::validDBName( database ) ); - scoped_lock l( _lock ); + boost::lock_guard<boost::mutex> l( _lock ); DBConfigPtr& dbConfig = _databases[database]; if( ! dbConfig ){ @@ -197,14 +189,14 @@ namespace mongo { void Grid::removeDB( const std::string& database ) { uassert( 10186 , "removeDB expects db name" , database.find( '.' ) == string::npos ); - scoped_lock l( _lock ); + boost::lock_guard<boost::mutex> l( _lock ); _databases.erase( database ); } void Grid::removeDBIfExists( const DBConfig& database ) { - scoped_lock l( _lock ); + boost::lock_guard<boost::mutex> l( _lock ); map<string,DBConfigPtr>::iterator it = _databases.find( database.getName() ); if( it != _databases.end() && it->second.get() == &database ){ @@ -650,7 +642,7 @@ namespace mongo { } void Grid::flushConfig() { - scoped_lock lk( _lock ); + boost::lock_guard<boost::mutex> lk( _lock ); _databases.clear(); } diff --git a/src/mongo/s/grid.h b/src/mongo/s/grid.h index 1543e354567..89822916a73 100644 --- a/src/mongo/s/grid.h +++ b/src/mongo/s/grid.h @@ -48,7 +48,6 @@ namespace mongo { class Grid { public: Grid(); - ~Grid(); /** * gets the config the db. diff --git a/src/mongo/s/shard.cpp b/src/mongo/s/shard.cpp index 6df1eeb915d..14804c9a0de 100644 --- a/src/mongo/s/shard.cpp +++ b/src/mongo/s/shard.cpp @@ -89,7 +89,6 @@ namespace mongo { class StaticShardInfo { public: - StaticShardInfo() : _mutex("StaticShardInfo"), _rsMutex("RSNameMap") { } void reload() { list<BSONObj> all; @@ -110,7 +109,7 @@ namespace mongo { conn.done(); } - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); // We use the _lookup table for all shards and for the primary config DB. The config DB info, // however, does not come from the ShardNS::shard. So when cleaning the _lookup table we leave @@ -152,7 +151,7 @@ namespace mongo { } ShardPtr findIfExists( const string& shardName ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); ShardMap::iterator i = _lookup.find( shardName ); if ( i != _lookup.end() ) return i->second; return ShardPtr(); @@ -166,7 +165,7 @@ namespace mongo { errmsg.empty()); if (connStr.type() == ConnectionString::SET) { - scoped_lock lk(_rsMutex); + boost::lock_guard<boost::mutex> lk(_rsMutex); ShardMap::iterator iter = _rsLookup.find(connStr.getSetName()); if (iter == _rsLookup.end()) { @@ -176,7 +175,7 @@ namespace mongo { return iter->second; } else { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); ShardMap::iterator iter = _lookup.find(ident); if (iter == _lookup.end()) { @@ -206,7 +205,7 @@ namespace mongo { // Note: this doesn't refresh the table if the name isn't found, so it's possible that // a newly added shard/Replica Set may not be found. Shard lookupRSName( const string& name) { - scoped_lock lk( _rsMutex ); + boost::lock_guard<boost::mutex> lk( _rsMutex ); ShardMap::iterator i = _rsLookup.find( name ); return (i == _rsLookup.end()) ? Shard::EMPTY : *(i->second.get()); @@ -215,13 +214,13 @@ namespace mongo { // Useful for ensuring our shard data will not be modified while we use it Shard findCopy( const string& ident ){ ShardPtr found = findWithRetry(ident); - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); massert( 13128 , (string)"can't find shard for: " + ident , found.get() ); return *found.get(); } void set( const string& name , const Shard& s , bool setName = true , bool setAddr = true ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); ShardPtr ss( new Shard( s ) ); if ( setName ) _lookup[name] = ss; @@ -235,7 +234,7 @@ namespace mongo { const ConnectionString& cs = s->getAddress(); if ( cs.type() == ConnectionString::SET ) { if ( cs.getSetName().size() ) { - scoped_lock lk( _rsMutex); + boost::lock_guard<boost::mutex> lk( _rsMutex); _rsLookup[ cs.getSetName() ] = s; } vector<HostAndPort> servers = cs.getServers(); @@ -246,7 +245,7 @@ namespace mongo { } void remove( const string& name ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); for ( ShardMap::iterator i = _lookup.begin(); i!=_lookup.end(); ) { ShardPtr s = i->second; if ( s->getName() == name ) { @@ -268,7 +267,7 @@ namespace mongo { } void getAllShards( vector<ShardPtr>& all ) const { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); std::set<string> seen; for ( ShardMap::const_iterator i = _lookup.begin(); i!=_lookup.end(); ++i ) { const ShardPtr& s = i->second; @@ -282,7 +281,7 @@ namespace mongo { } void getAllShards( vector<Shard>& all ) const { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); std::set<string> seen; for ( ShardMap::const_iterator i = _lookup.begin(); i!=_lookup.end(); ++i ) { const ShardPtr& s = i->second; @@ -297,7 +296,7 @@ namespace mongo { bool isAShardNode( const string& addr ) const { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); // check direct nods or set names ShardMap::const_iterator i = _lookup.find( addr ); @@ -317,7 +316,7 @@ namespace mongo { } bool getShardMap( BSONObjBuilder& result , string& errmsg ) const { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); BSONObjBuilder b( _lookup.size() + 50 ); diff --git a/src/mongo/s/version_manager.cpp b/src/mongo/s/version_manager.cpp index 9396f12a8a3..708ca3efbe7 100644 --- a/src/mongo/s/version_manager.cpp +++ b/src/mongo/s/version_manager.cpp @@ -59,12 +59,8 @@ namespace mongo { */ struct ConnectionShardStatus { - ConnectionShardStatus() - : _mutex( "ConnectionShardStatus" ) { - } - bool hasAnySequenceSet(DBClientBase* conn) { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); SequenceMap::const_iterator seenConnIt = _map.find(conn->getConnectionId()); return seenConnIt != _map.end() && seenConnIt->second.size() > 0; @@ -74,7 +70,7 @@ namespace mongo { const string& ns, unsigned long long* sequence) { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); SequenceMap::const_iterator seenConnIt = _map.find(conn->getConnectionId()); if (seenConnIt == _map.end()) @@ -89,12 +85,12 @@ namespace mongo { } void setSequence( DBClientBase * conn , const string& ns , const unsigned long long& s ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _map[conn->getConnectionId()][ns] = s; } void reset( DBClientBase * conn ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _map.erase( conn->getConnectionId() ); } diff --git a/src/mongo/scripting/engine.cpp b/src/mongo/scripting/engine.cpp index b9403621652..3f56ee467b3 100644 --- a/src/mongo/scripting/engine.cpp +++ b/src/mongo/scripting/engine.cpp @@ -315,10 +315,8 @@ namespace { namespace { class ScopeCache { public: - ScopeCache() : _mutex("ScopeCache") {} - void release(const string& poolName, const boost::shared_ptr<Scope>& scope) { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); if (scope->hasOutOfMemoryException()) { // make some room @@ -344,7 +342,7 @@ namespace { } boost::shared_ptr<Scope> tryAcquire(OperationContext* txn, const string& poolName) { - scoped_lock lk(_mutex); + boost::lock_guard<boost::mutex> lk(_mutex); for (Pools::iterator it = _pools.begin(); it != _pools.end(); ++it) { if (it->poolName == poolName) { diff --git a/src/mongo/scripting/engine_v8-3.25.cpp b/src/mongo/scripting/engine_v8-3.25.cpp index 877bc32308b..2cb47b814c1 100644 --- a/src/mongo/scripting/engine_v8-3.25.cpp +++ b/src/mongo/scripting/engine_v8-3.25.cpp @@ -394,7 +394,7 @@ namespace mongo { } void V8ScriptEngine::interrupt(unsigned opId) { - mongo::mutex::scoped_lock intLock(_globalInterruptLock); + boost::lock_guard<boost::mutex> intLock(_globalInterruptLock); OpIdToScopeMap::iterator iScope = _opToScopeMap.find(opId); if (iScope == _opToScopeMap.end()) { // got interrupt request for a scope that no longer exists @@ -407,7 +407,7 @@ namespace mongo { } void V8ScriptEngine::interruptAll() { - mongo::mutex::scoped_lock interruptLock(_globalInterruptLock); + boost::lock_guard<boost::mutex> interruptLock(_globalInterruptLock); for (OpIdToScopeMap::iterator iScope = _opToScopeMap.begin(); iScope != _opToScopeMap.end(); ++iScope) { iScope->second->kill(); @@ -415,7 +415,7 @@ namespace mongo { } void V8Scope::registerOperation(OperationContext* txn) { - scoped_lock giLock(_engine->_globalInterruptLock); + boost::lock_guard<boost::mutex> giLock(_engine->_globalInterruptLock); invariant(_opId == 0); _opId = txn->getOpID(); _engine->_opToScopeMap[_opId] = this; @@ -427,7 +427,7 @@ namespace mongo { } void V8Scope::unregisterOperation() { - scoped_lock giLock(_engine->_globalInterruptLock); + boost::lock_guard<boost::mutex> giLock(_engine->_globalInterruptLock); LOG(2) << "V8Scope " << static_cast<const void*>(this) << " unregistered for op " << _opId << endl; if (_opId != 0) { @@ -441,7 +441,7 @@ namespace mongo { bool V8Scope::nativePrologue() { v8::Locker l(_isolate); - mongo::mutex::scoped_lock cbEnterLock(_interruptLock); + boost::lock_guard<boost::mutex> cbEnterLock(_interruptLock); if (v8::V8::IsExecutionTerminating(_isolate)) { LOG(2) << "v8 execution interrupted. isolate: " << static_cast<const void*>(_isolate) << endl; @@ -460,7 +460,7 @@ namespace mongo { bool V8Scope::nativeEpilogue() { v8::Locker l(_isolate); - mongo::mutex::scoped_lock cbLeaveLock(_interruptLock); + boost::lock_guard<boost::mutex> cbLeaveLock(_interruptLock); _inNativeExecution = false; if (v8::V8::IsExecutionTerminating(_isolate)) { LOG(2) << "v8 execution interrupted. isolate: " @@ -477,7 +477,7 @@ namespace mongo { } void V8Scope::kill() { - mongo::mutex::scoped_lock interruptLock(_interruptLock); + boost::lock_guard<boost::mutex> interruptLock(_interruptLock); if (!_inNativeExecution) { // Set the TERMINATE flag on the stack guard for this isolate. // This won't happen between calls to nativePrologue and nativeEpilogue(). diff --git a/src/mongo/scripting/engine_v8.cpp b/src/mongo/scripting/engine_v8.cpp index 3df613e4961..62c38f3bd8f 100644 --- a/src/mongo/scripting/engine_v8.cpp +++ b/src/mongo/scripting/engine_v8.cpp @@ -351,7 +351,6 @@ namespace mongo { } V8ScriptEngine::V8ScriptEngine() : - _globalInterruptLock("GlobalV8InterruptLock"), _opToScopeMap(), _deadlineMonitor() { } @@ -374,7 +373,7 @@ namespace mongo { } void V8ScriptEngine::interrupt(unsigned opId) { - mongo::mutex::scoped_lock intLock(_globalInterruptLock); + boost::lock_guard<boost::mutex> intLock(_globalInterruptLock); OpIdToScopeMap::iterator iScope = _opToScopeMap.find(opId); if (iScope == _opToScopeMap.end()) { // got interrupt request for a scope that no longer exists @@ -387,7 +386,7 @@ namespace mongo { } void V8ScriptEngine::interruptAll() { - mongo::mutex::scoped_lock interruptLock(_globalInterruptLock); + boost::lock_guard<boost::mutex> interruptLock(_globalInterruptLock); for (OpIdToScopeMap::iterator iScope = _opToScopeMap.begin(); iScope != _opToScopeMap.end(); ++iScope) { iScope->second->kill(); @@ -395,7 +394,7 @@ namespace mongo { } void V8Scope::registerOperation(OperationContext* txn) { - scoped_lock giLock(_engine->_globalInterruptLock); + boost::lock_guard<boost::mutex> giLock(_engine->_globalInterruptLock); invariant(_opId == 0); _opId = txn->getOpID(); _engine->_opToScopeMap[_opId] = this; @@ -407,7 +406,7 @@ namespace mongo { } void V8Scope::unregisterOperation() { - scoped_lock giLock(_engine->_globalInterruptLock); + boost::lock_guard<boost::mutex> giLock(_engine->_globalInterruptLock); LOG(2) << "V8Scope " << static_cast<const void*>(this) << " unregistered for op " << _opId << endl; if (_opId != 0) { // scope is currently associated with an operation id @@ -420,7 +419,7 @@ namespace mongo { bool V8Scope::nativePrologue() { v8::Locker l(_isolate); - mongo::mutex::scoped_lock cbEnterLock(_interruptLock); + boost::lock_guard<boost::mutex> cbEnterLock(_interruptLock); if (v8::V8::IsExecutionTerminating(_isolate)) { LOG(2) << "v8 execution interrupted. isolate: " << static_cast<const void*>(_isolate) << endl; return false; @@ -437,7 +436,7 @@ namespace mongo { bool V8Scope::nativeEpilogue() { v8::Locker l(_isolate); - mongo::mutex::scoped_lock cbLeaveLock(_interruptLock); + boost::lock_guard<boost::mutex> cbLeaveLock(_interruptLock); _inNativeExecution = false; if (v8::V8::IsExecutionTerminating(_isolate)) { LOG(2) << "v8 execution interrupted. isolate: " << static_cast<const void*>(_isolate) << endl; @@ -452,7 +451,7 @@ namespace mongo { } void V8Scope::kill() { - mongo::mutex::scoped_lock interruptLock(_interruptLock); + boost::lock_guard<boost::mutex> interruptLock(_interruptLock); if (!_inNativeExecution) { // Set the TERMINATE flag on the stack guard for this isolate. // This won't happen between calls to nativePrologue and nativeEpilogue(). @@ -492,7 +491,6 @@ namespace mongo { : _engine(engine), _connectState(NOT), _cpuProfiler(), - _interruptLock("ScopeInterruptLock"), _inNativeExecution(true), _pendingKill(false), _opId(0), diff --git a/src/mongo/scripting/v8_deadline_monitor.h b/src/mongo/scripting/v8_deadline_monitor.h index 45913e65b48..1d892ed8752 100644 --- a/src/mongo/scripting/v8_deadline_monitor.h +++ b/src/mongo/scripting/v8_deadline_monitor.h @@ -67,7 +67,6 @@ namespace mongo { public: DeadlineMonitor() : _tasks(), - _deadlineMutex("DeadlineMonitor"), _newDeadlineAvailable(), _nearestDeadlineWallclock(kMaxDeadline), _monitorThread(&mongo::DeadlineMonitor<_Task>::deadlineMonitorThread, this) { @@ -88,7 +87,7 @@ namespace mongo { */ void startDeadline(_Task* const task, uint64_t timeoutMs) { uint64_t now = curTimeMillis64(); - scoped_lock lk(_deadlineMutex); + boost::lock_guard<boost::mutex> lk(_deadlineMutex); // insert or update the deadline std::pair<typename TaskDeadlineMap::iterator, bool> inserted = @@ -110,7 +109,7 @@ namespace mongo { * @return true if the task was found and erased */ bool stopDeadline(_Task* const task) { - scoped_lock lk(_deadlineMutex); + boost::lock_guard<boost::mutex> lk(_deadlineMutex); return _tasks.erase(task); } @@ -121,7 +120,7 @@ namespace mongo { * _Task::kill() is invoked. */ void deadlineMonitorThread() { - scoped_lock lk(_deadlineMutex); + boost::unique_lock<boost::mutex> lk(_deadlineMutex); while (true) { // get the next interval to wait @@ -131,11 +130,11 @@ namespace mongo { while (_nearestDeadlineWallclock > now) { uint64_t nearestDeadlineMs; if (_nearestDeadlineWallclock == kMaxDeadline) { - _newDeadlineAvailable.wait(lk.boost()); + _newDeadlineAvailable.wait(lk); } else { nearestDeadlineMs = _nearestDeadlineWallclock - now; - _newDeadlineAvailable.timed_wait(lk.boost(), + _newDeadlineAvailable.timed_wait(lk, boost::posix_time::milliseconds(nearestDeadlineMs)); } now = curTimeMillis64(); diff --git a/src/mongo/scripting/v8_deadline_monitor_test.cpp b/src/mongo/scripting/v8_deadline_monitor_test.cpp index 1ad95d63816..f6f43bd8ff4 100644 --- a/src/mongo/scripting/v8_deadline_monitor_test.cpp +++ b/src/mongo/scripting/v8_deadline_monitor_test.cpp @@ -43,18 +43,18 @@ namespace mongo { class TaskGroup { public: - TaskGroup() : _m("TestGroup"), _c(), _killCount(0), _targetKillCount(0) { } + TaskGroup() : _c(), _killCount(0), _targetKillCount(0) { } void noteKill() { - scoped_lock lk(_m); + boost::lock_guard<boost::mutex> lk(_m); ++_killCount; if (_killCount >= _targetKillCount) _c.notify_one(); } void waitForKillCount(uint64_t target) { - scoped_lock lk(_m); + boost::unique_lock<boost::mutex> lk(_m); _targetKillCount = target; while (_killCount < _targetKillCount) - _c.wait(lk.boost()); + _c.wait(lk); } private: mongo::mutex _m; diff --git a/src/mongo/shell/dbshell.cpp b/src/mongo/shell/dbshell.cpp index 3e6195ff78a..77c807ae908 100644 --- a/src/mongo/shell/dbshell.cpp +++ b/src/mongo/shell/dbshell.cpp @@ -185,7 +185,7 @@ namespace mongo { void exitCleanly(ExitCode code) { { - mongo::mutex::scoped_lock lk(mongo::shell_utils::mongoProgramOutputMutex); + boost::lock_guard<boost::mutex> lk(mongo::shell_utils::mongoProgramOutputMutex); mongo::dbexitCalled = true; } @@ -896,7 +896,7 @@ int _main( int argc, char* argv[], char **envp ) { } { - mongo::mutex::scoped_lock lk(mongo::shell_utils::mongoProgramOutputMutex); + boost::lock_guard<boost::mutex> lk(mongo::shell_utils::mongoProgramOutputMutex); mongo::dbexitCalled = true; } return 0; diff --git a/src/mongo/shell/shell_utils.cpp b/src/mongo/shell/shell_utils.cpp index ee489a75dd4..77cf1103f1d 100644 --- a/src/mongo/shell/shell_utils.cpp +++ b/src/mongo/shell/shell_utils.cpp @@ -286,22 +286,20 @@ namespace mongo { return _confirmed = matchedY; } - ConnectionRegistry::ConnectionRegistry() : - _mutex( "connectionRegistryMutex" ) { - } - + ConnectionRegistry::ConnectionRegistry() = default; + void ConnectionRegistry::registerConnection( DBClientWithCommands &client ) { BSONObj info; if ( client.runCommand( "admin", BSON( "whatsmyuri" << 1 ), info ) ) { string connstr = dynamic_cast<DBClientBase&>( client ).getServerAddress(); - mongo::mutex::scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _connectionUris[ connstr ].insert( info[ "you" ].str() ); } } void ConnectionRegistry::killOperationsOnAllConnections( bool withPrompt ) const { Prompter prompter( "do you want to kill the current op(s) on the server?" ); - mongo::mutex::scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); for( map<string,set<string> >::const_iterator i = _connectionUris.begin(); i != _connectionUris.end(); ++i ) { string errmsg; diff --git a/src/mongo/shell/shell_utils_launcher.cpp b/src/mongo/shell/shell_utils_launcher.cpp index 48ff2dd3c36..07d1828eaf5 100644 --- a/src/mongo/shell/shell_utils_launcher.cpp +++ b/src/mongo/shell/shell_utils_launcher.cpp @@ -169,12 +169,12 @@ namespace mongo { ProgramRegistry ®istry = *( new ProgramRegistry() ); void goingAwaySoon() { - mongo::mutex::scoped_lock lk( mongoProgramOutputMutex ); + boost::lock_guard<boost::mutex> lk( mongoProgramOutputMutex ); mongo::dbexitCalled = true; } void ProgramOutputMultiplexer::appendLine( int port, ProcessId pid, const char *line ) { - mongo::mutex::scoped_lock lk( mongoProgramOutputMutex ); + boost::lock_guard<boost::mutex> lk( mongoProgramOutputMutex ); if( mongo::dbexitCalled ) throw "program is terminating"; stringstream buf; if ( port > 0 ) @@ -187,7 +187,7 @@ namespace mongo { } string ProgramOutputMultiplexer::str() const { - mongo::mutex::scoped_lock lk( mongoProgramOutputMutex ); + boost::lock_guard<boost::mutex> lk( mongoProgramOutputMutex ); string ret = _buffer.str(); size_t len = ret.length(); if ( len > 100000 ) { @@ -197,7 +197,7 @@ namespace mongo { } void ProgramOutputMultiplexer::clear() { - mongo::mutex::scoped_lock lk( mongoProgramOutputMutex ); + boost::lock_guard<boost::mutex> lk( mongoProgramOutputMutex ); _buffer.str( "" ); } diff --git a/src/mongo/util/background.cpp b/src/mongo/util/background.cpp index 090b665ddd4..c98e674ccc8 100644 --- a/src/mongo/util/background.cpp +++ b/src/mongo/util/background.cpp @@ -34,6 +34,7 @@ #include "mongo/util/background.h" #include <boost/thread/condition.hpp> +#include <boost/thread/mutex.hpp> #include <boost/thread/once.hpp> #include <boost/thread/thread.hpp> @@ -56,9 +57,7 @@ namespace mongo { class PeriodicTaskRunner : public BackgroundJob { public: - PeriodicTaskRunner() - : _mutex("PeriodicTaskRunner") - , _shutdownRequested(false) {} + PeriodicTaskRunner() : _shutdownRequested(false) {} void add( PeriodicTask* task ); void remove( PeriodicTask* task ); @@ -85,7 +84,7 @@ namespace mongo { void _runTask( PeriodicTask* task ); // _mutex protects the _shutdownRequested flag and the _tasks vector. - mongo::mutex _mutex; + boost::mutex _mutex; // The condition variable is used to sleep for the interval between task // executions, and is notified when the _shutdownRequested flag is toggled. @@ -133,12 +132,9 @@ namespace mongo { // both the BackgroundJob and the internal thread point to JobStatus struct BackgroundJob::JobStatus { - JobStatus() - : mutex( "backgroundJob" ) - , state( NotStarted ) { - } + JobStatus() : state(NotStarted) {} - mongo::mutex mutex; + boost::mutex mutex; boost::condition done; State state; }; @@ -182,7 +178,7 @@ namespace mongo { { // It is illegal to access any state owned by this BackgroundJob after leaving this // scope, with the exception of the call to 'delete this' below. - scoped_lock l( _status->mutex ); + boost::unique_lock<boost::mutex> l( _status->mutex ); _status->state = Done; _status->done.notify_all(); } @@ -192,7 +188,7 @@ namespace mongo { } void BackgroundJob::go() { - scoped_lock l( _status->mutex ); + boost::unique_lock<boost::mutex> l( _status->mutex ); massert( 17234, mongoutils::str::stream() << "backgroundJob already running: " << name(), _status->state != Running ); @@ -206,7 +202,7 @@ namespace mongo { } Status BackgroundJob::cancel() { - scoped_lock l( _status->mutex ); + boost::unique_lock<boost::mutex> l( _status->mutex ); if ( _status->state == Running ) return Status( ErrorCodes::IllegalOperation, @@ -222,27 +218,27 @@ namespace mongo { bool BackgroundJob::wait( unsigned msTimeOut ) { verify( !_selfDelete ); // you cannot call wait on a self-deleting job - scoped_lock l( _status->mutex ); + boost::unique_lock<boost::mutex> l( _status->mutex ); while ( _status->state != Done ) { if ( msTimeOut ) { boost::xtime deadline = incxtimemillis( msTimeOut ); - if ( !_status->done.timed_wait( l.boost() , deadline ) ) + if ( !_status->done.timed_wait( l , deadline ) ) return false; } else { - _status->done.wait( l.boost() ); + _status->done.wait( l ); } } return true; } BackgroundJob::State BackgroundJob::getState() const { - scoped_lock l( _status->mutex ); + boost::unique_lock<boost::mutex> l( _status->mutex ); return _status->state; } bool BackgroundJob::running() const { - scoped_lock l( _status->mutex ); + boost::unique_lock<boost::mutex> l( _status->mutex ); return _status->state == Running; } @@ -297,12 +293,12 @@ namespace mongo { } void PeriodicTaskRunner::add( PeriodicTask* task ) { - mutex::scoped_lock lock( _mutex ); + boost::lock_guard<boost::mutex> lock( _mutex ); _tasks.push_back( task ); } void PeriodicTaskRunner::remove( PeriodicTask* task ) { - mutex::scoped_lock lock( _mutex ); + boost::lock_guard<boost::mutex> lock( _mutex ); for ( size_t i = 0; i != _tasks.size(); i++ ) { if ( _tasks[i] == task ) { _tasks[i] = NULL; @@ -313,7 +309,7 @@ namespace mongo { Status PeriodicTaskRunner::stop( int gracePeriodMillis ) { { - mutex::scoped_lock lock( _mutex ); + boost::lock_guard<boost::mutex> lock( _mutex ); _shutdownRequested = true; _cond.notify_one(); } @@ -332,10 +328,10 @@ namespace mongo { const stdx::function<bool()> predicate = stdx::bind( &PeriodicTaskRunner::_isShutdownRequested, this ); - mutex::scoped_lock lock( _mutex ); + boost::unique_lock<boost::mutex> lock( _mutex ); while ( !predicate() ) { const boost::xtime deadline = incxtimemillis( waitMillis ); - if ( !_cond.timed_wait( lock.boost(), deadline, predicate ) ) + if ( !_cond.timed_wait( lock, deadline, predicate ) ) _runTasks(); } } diff --git a/src/mongo/util/background_job_test.cpp b/src/mongo/util/background_job_test.cpp index 030c0f3120e..1b2f197afcc 100644 --- a/src/mongo/util/background_job_test.cpp +++ b/src/mongo/util/background_job_test.cpp @@ -104,9 +104,7 @@ namespace { class Job : public BackgroundJob { public: - Job() - : _mutex("BackgroundJobLifeCycle::Go") - , _hasRun(false) {} + Job() : _hasRun(false) {} virtual std::string name() const { return "BackgroundLifeCycle::CannotCallGoAgain"; @@ -114,7 +112,7 @@ namespace { virtual void run() { { - mongo::scoped_lock lock( _mutex ); + boost::lock_guard<boost::mutex> lock( _mutex ); ASSERT_FALSE( _hasRun ); _hasRun = true; } diff --git a/src/mongo/util/concurrency/mutex.h b/src/mongo/util/concurrency/mutex.h index 67eb565c37d..5e207e7662b 100644 --- a/src/mongo/util/concurrency/mutex.h +++ b/src/mongo/util/concurrency/mutex.h @@ -75,45 +75,7 @@ namespace mongo { ~StaticObserver() { _destroyingStatics = true; } }; - /** On pthread systems, it is an error to destroy a mutex while held (boost mutex - * may use pthread). Static global mutexes may be held upon shutdown in our - * implementation, and this way we avoid destroying them. - * NOT recursive. - */ - class mutex : boost::noncopyable { - public: - const char * const _name; - // NOINLINE so that 'mutex::mutex' is always in the frame, this makes - // it easier for us to suppress the leaks caused by the static observer. - NOINLINE_DECL mutex(const char *name) : _name(name) - { - _m = new boost::timed_mutex(); - IGNORE_OBJECT( _m ); // Turn-off heap checking on _m - } - ~mutex() { - if( !StaticObserver::_destroyingStatics ) { - UNIGNORE_OBJECT( _m ); - delete _m; - } - } - - class scoped_lock : boost::noncopyable { - public: - scoped_lock( mongo::mutex &m ) : - _l( m.boost() ) { - } - ~scoped_lock() { - } - boost::unique_lock<boost::timed_mutex>& boost() { return _l; } - private: - boost::unique_lock<boost::timed_mutex> _l; - }; - private: - boost::timed_mutex &boost() { return *_m; } - boost::timed_mutex *_m; - }; - - typedef mongo::mutex::scoped_lock scoped_lock; + using mutex = boost::mutex; /** The concept with SimpleMutex is that it is a basic lock/unlock with no special functionality (such as try and try timeout). Thus it can be diff --git a/src/mongo/util/concurrency/synchronization.cpp b/src/mongo/util/concurrency/synchronization.cpp index 3121989123a..d7cf3575c32 100644 --- a/src/mongo/util/concurrency/synchronization.cpp +++ b/src/mongo/util/concurrency/synchronization.cpp @@ -59,20 +59,20 @@ namespace { } } - Notification::Notification() : _mutex ( "Notification" ) { + Notification::Notification() { lookFor = 1; cur = 0; } void Notification::waitToBeNotified() { - scoped_lock lock( _mutex ); + boost::unique_lock<boost::mutex> lock( _mutex ); while ( lookFor != cur ) - _condition.wait( lock.boost() ); + _condition.wait(lock); lookFor++; } void Notification::notifyOne() { - scoped_lock lock( _mutex ); + boost::lock_guard<boost::mutex> lock( _mutex ); verify( cur != lookFor ); cur++; _condition.notify_one(); @@ -80,36 +80,36 @@ namespace { /* --- NotifyAll --- */ - NotifyAll::NotifyAll() : _mutex("NotifyAll") { + NotifyAll::NotifyAll() { _lastDone = 0; _lastReturned = 0; _nWaiting = 0; } NotifyAll::When NotifyAll::now() { - scoped_lock lock( _mutex ); + boost::lock_guard<boost::mutex> lock( _mutex ); return ++_lastReturned; } void NotifyAll::waitFor(When e) { - scoped_lock lock( _mutex ); + boost::unique_lock<boost::mutex> lock( _mutex ); ++_nWaiting; while( _lastDone < e ) { - _condition.wait( lock.boost() ); + _condition.wait(lock); } } void NotifyAll::awaitBeyondNow() { - scoped_lock lock( _mutex ); + boost::unique_lock<boost::mutex> lock( _mutex ); ++_nWaiting; When e = ++_lastReturned; while( _lastDone <= e ) { - _condition.wait( lock.boost() ); + _condition.wait(lock); } } void NotifyAll::notifyAll(When e) { - scoped_lock lock( _mutex ); + boost::unique_lock<boost::mutex> lock( _mutex ); _lastDone = e; _nWaiting = 0; _condition.notify_all(); diff --git a/src/mongo/util/concurrency/thread_pool.cpp b/src/mongo/util/concurrency/thread_pool.cpp index 2f16d4e5fa4..3056294e163 100644 --- a/src/mongo/util/concurrency/thread_pool.cpp +++ b/src/mongo/util/concurrency/thread_pool.cpp @@ -102,7 +102,7 @@ namespace mongo { }; ThreadPool::ThreadPool(int nThreads, const std::string& threadNamePrefix) - : _mutex("ThreadPool"), _tasksRemaining(0) + : _tasksRemaining(0) , _nThreads(nThreads) , _threadNamePrefix(threadNamePrefix) { startThreads(); @@ -111,13 +111,13 @@ namespace mongo { ThreadPool::ThreadPool(const DoNotStartThreadsTag&, int nThreads, const std::string& threadNamePrefix) - : _mutex("ThreadPool"), _tasksRemaining(0) + : _tasksRemaining(0) , _nThreads(nThreads) , _threadNamePrefix(threadNamePrefix) { } void ThreadPool::startThreads() { - scoped_lock lock(_mutex); + boost::lock_guard<boost::mutex> lock(_mutex); for (int i = 0; i < _nThreads; ++i) { const std::string threadName(_threadNamePrefix.empty() ? _threadNamePrefix : @@ -145,14 +145,14 @@ namespace mongo { } void ThreadPool::join() { - scoped_lock lock(_mutex); + boost::unique_lock<boost::mutex> lock(_mutex); while(_tasksRemaining) { - _condition.wait(lock.boost()); + _condition.wait(lock); } } void ThreadPool::schedule(Task task) { - scoped_lock lock(_mutex); + boost::lock_guard<boost::mutex> lock(_mutex); _tasksRemaining++; @@ -167,7 +167,7 @@ namespace mongo { // should only be called by a worker from the worker thread void ThreadPool::task_done(Worker* worker) { - scoped_lock lock(_mutex); + boost::lock_guard<boost::mutex> lock(_mutex); if (!_tasks.empty()) { worker->set_task(_tasks.front()); diff --git a/src/mongo/util/concurrency/ticketholder.cpp b/src/mongo/util/concurrency/ticketholder.cpp index efec9b50ee2..2bda04c5c10 100644 --- a/src/mongo/util/concurrency/ticketholder.cpp +++ b/src/mongo/util/concurrency/ticketholder.cpp @@ -122,38 +122,33 @@ namespace mongo { #else - TicketHolder::TicketHolder( int num ) - : _outof(num), - _num(num), - _mutex("TicketHolder") { - } + TicketHolder::TicketHolder( int num ) : _outof(num), _num(num) {} - TicketHolder::~TicketHolder(){ - } + TicketHolder::~TicketHolder() = default; bool TicketHolder::tryAcquire() { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); return _tryAcquire(); } void TicketHolder::waitForTicket() { - scoped_lock lk( _mutex ); + boost::unique_lock<boost::mutex> lk( _mutex ); while( ! _tryAcquire() ) { - _newTicket.wait( lk.boost() ); + _newTicket.wait( lk ); } } void TicketHolder::release() { { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _num++; } _newTicket.notify_one(); } Status TicketHolder::resize( int newSize ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); int used = _outof.load() - _num; if ( used > newSize ) { diff --git a/src/mongo/util/fail_point.cpp b/src/mongo/util/fail_point.cpp index a1d00b7830f..bbeb9cf00c9 100644 --- a/src/mongo/util/fail_point.cpp +++ b/src/mongo/util/fail_point.cpp @@ -80,12 +80,7 @@ namespace { failPointPrng.getMake()->resetSeed(seed); } - FailPoint::FailPoint(): - _fpInfo(0), - _mode(off), - _timesOrPeriod(0), - _modMutex("failPointMutex") { - } + FailPoint::FailPoint() : _fpInfo(0), _mode(off), _timesOrPeriod(0) {} void FailPoint::shouldFailCloseBlock() { _fpInfo.subtractAndFetch(1); @@ -100,7 +95,7 @@ namespace { * 3. Sets the new mode. */ - scoped_lock scoped(_modMutex); + boost::lock_guard<boost::mutex> scoped(_modMutex); // Step 1 disableFailPoint(); @@ -193,7 +188,7 @@ namespace { BSONObj FailPoint::toBSON() const { BSONObjBuilder builder; - scoped_lock scoped(_modMutex); + boost::lock_guard<boost::mutex> scoped(_modMutex); builder.append("mode", _mode); builder.append("data", _data); diff --git a/src/mongo/util/fail_point.h b/src/mongo/util/fail_point.h index e2ff5089fd7..6ca1df82e14 100644 --- a/src/mongo/util/fail_point.h +++ b/src/mongo/util/fail_point.h @@ -28,10 +28,11 @@ #pragma once +#include <boost/thread/mutex.hpp> + #include "mongo/base/disallow_copying.h" #include "mongo/db/jsobj.h" #include "mongo/platform/atomic_word.h" -#include "mongo/util/concurrency/mutex.h" namespace mongo { /** @@ -157,7 +158,7 @@ namespace mongo { BSONObj _data; // protects _mode, _timesOrPeriod, _data - mutable mutex _modMutex; + mutable boost::mutex _modMutex; /** * Enables this fail point. diff --git a/src/mongo/util/file_allocator.cpp b/src/mongo/util/file_allocator.cpp index cf60e1cdadb..5acf3d68cb2 100644 --- a/src/mongo/util/file_allocator.cpp +++ b/src/mongo/util/file_allocator.cpp @@ -117,9 +117,7 @@ namespace mongo { return parent; } - FileAllocator::FileAllocator() - : _pendingMutex("FileAllocator"), _failed() { - } + FileAllocator::FileAllocator() : _failed() {} void FileAllocator::start() { @@ -127,7 +125,7 @@ namespace mongo { } void FileAllocator::requestAllocation( const string &name, long &size ) { - scoped_lock lk( _pendingMutex ); + boost::lock_guard<boost::mutex> lk( _pendingMutex ); if ( _failed ) return; long oldSize = prevSize( name ); @@ -141,7 +139,7 @@ namespace mongo { } void FileAllocator::allocateAsap( const string &name, unsigned long long &size ) { - scoped_lock lk( _pendingMutex ); + boost::unique_lock<boost::mutex> lk( _pendingMutex ); // In case the allocator is in failed state, check once before starting so that subsequent // requests for the same database would fail fast after the first one has failed. @@ -166,7 +164,7 @@ namespace mongo { _pendingUpdated.notify_all(); while( inProgress( name ) ) { checkFailure(); - _pendingUpdated.wait( lk.boost() ); + _pendingUpdated.wait(lk); } } @@ -174,9 +172,9 @@ namespace mongo { void FileAllocator::waitUntilFinished() const { if ( _failed ) return; - scoped_lock lk( _pendingMutex ); + boost::unique_lock<boost::mutex> lk( _pendingMutex ); while( _pending.size() != 0 ) - _pendingUpdated.wait( lk.boost() ); + _pendingUpdated.wait(lk); } // TODO: pull this out to per-OS files once they exist @@ -361,15 +359,15 @@ namespace mongo { } while( 1 ) { { - scoped_lock lk( fa->_pendingMutex ); + boost::unique_lock<boost::mutex> lk( fa->_pendingMutex ); if ( fa->_pending.size() == 0 ) - fa->_pendingUpdated.wait( lk.boost() ); + fa->_pendingUpdated.wait(lk); } while( 1 ) { string name; long size = 0; { - scoped_lock lk( fa->_pendingMutex ); + boost::lock_guard<boost::mutex> lk( fa->_pendingMutex ); if ( fa->_pending.size() == 0 ) break; name = fa->_pending.front(); @@ -441,7 +439,7 @@ namespace mongo { } { - scoped_lock lk(fa->_pendingMutex); + boost::lock_guard<boost::mutex> lk(fa->_pendingMutex); fa->_failed = true; // TODO: Should we remove the file from pending? @@ -454,7 +452,7 @@ namespace mongo { } { - scoped_lock lk( fa->_pendingMutex ); + boost::lock_guard<boost::mutex> lk( fa->_pendingMutex ); fa->_pendingSize.erase( name ); fa->_pending.pop_front(); fa->_pendingUpdated.notify_all(); diff --git a/src/mongo/util/mmap_win.cpp b/src/mongo/util/mmap_win.cpp index 354ca4df62c..86e6c1e6b6b 100644 --- a/src/mongo/util/mmap_win.cpp +++ b/src/mongo/util/mmap_win.cpp @@ -69,7 +69,7 @@ namespace mongo { // 2. Prevents calls to VirtualProtect while we remapping files. // Lock Ordering: // - If taken, must be after previewViews._m to prevent deadlocks - mutex mapViewMutex("mapView"); + mutex mapViewMutex; MAdvise::MAdvise(void *,unsigned, Advice) { } MAdvise::~MAdvise() { } @@ -165,7 +165,7 @@ namespace mongo { boost::lock_guard<boost::mutex> lk(_flushMutex); { - scoped_lock lk(mapViewMutex); + boost::lock_guard<boost::mutex> lk(mapViewMutex); for (vector<void*>::iterator i = views.begin(); i != views.end(); i++) { UnmapViewOfFile(*i); @@ -187,7 +187,7 @@ namespace mongo { void* MemoryMappedFile::createReadOnlyMap() { verify( maphandle ); - scoped_lock lk(mapViewMutex); + boost::lock_guard<boost::mutex> lk(mapViewMutex); void* readOnlyMapAddress = NULL; int current_retry = 0; @@ -299,7 +299,7 @@ namespace mongo { void *view = 0; { - scoped_lock lk(mapViewMutex); + boost::lock_guard<boost::mutex> lk(mapViewMutex); DWORD access = ( options & READONLY ) ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS; int current_retry = 0; @@ -364,7 +364,7 @@ namespace mongo { void* MemoryMappedFile::createPrivateMap() { verify( maphandle ); - scoped_lock lk(mapViewMutex); + boost::lock_guard<boost::mutex> lk(mapViewMutex); LPVOID thisAddress = getNextMemoryMappedFileLocation( len ); @@ -412,7 +412,7 @@ namespace mongo { privateViews.clearWritableBits(oldPrivateAddr, len); - scoped_lock lk(mapViewMutex); + boost::lock_guard<boost::mutex> lk(mapViewMutex); if( !UnmapViewOfFile(oldPrivateAddr) ) { DWORD dosError = GetLastError(); diff --git a/src/mongo/util/net/listen.cpp b/src/mongo/util/net/listen.cpp index f260573039e..8841be6a787 100644 --- a/src/mongo/util/net/listen.cpp +++ b/src/mongo/util/net/listen.cpp @@ -643,7 +643,7 @@ namespace mongo { std::set<std::string>* paths; { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); sockets = _sockets; _sockets = new std::set<int>(); paths = _socketPaths; diff --git a/src/mongo/util/net/listen.h b/src/mongo/util/net/listen.h index 6efb3a717b3..481a646239f 100644 --- a/src/mongo/util/net/listen.h +++ b/src/mongo/util/net/listen.h @@ -142,26 +142,25 @@ namespace mongo { class ListeningSockets { public: ListeningSockets() - : _mutex("ListeningSockets") - , _sockets( new std::set<int>() ) + : _sockets( new std::set<int>() ) , _socketPaths( new std::set<std::string>() ) { } void add( int sock ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _sockets->insert( sock ); } void addPath( const std::string& path ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _socketPaths->insert( path ); } void remove( int sock ) { - scoped_lock lk( _mutex ); + boost::lock_guard<boost::mutex> lk( _mutex ); _sockets->erase( sock ); } void closeAll(); static ListeningSockets* get(); private: - mongo::mutex _mutex; + boost::mutex _mutex; std::set<int>* _sockets; std::set<std::string>* _socketPaths; // for unix domain sockets static ListeningSockets* _instance; diff --git a/src/mongo/util/net/message_port.cpp b/src/mongo/util/net/message_port.cpp index 1ab8355dc05..3b6e3204417 100644 --- a/src/mongo/util/net/message_port.cpp +++ b/src/mongo/util/net/message_port.cpp @@ -115,9 +115,9 @@ namespace mongo { std::set<MessagingPort*> ports; mongo::mutex m; public: - Ports() : ports(), m("Ports") {} + Ports() : ports() {} void closeAll(unsigned skip_mask) { - scoped_lock bl(m); + boost::lock_guard<boost::mutex> bl(m); for ( std::set<MessagingPort*>::iterator i = ports.begin(); i != ports.end(); i++ ) { if( (*i)->tag & skip_mask ) continue; @@ -125,11 +125,11 @@ namespace mongo { } } void insert(MessagingPort* p) { - scoped_lock bl(m); + boost::lock_guard<boost::mutex> bl(m); ports.insert(p); } void erase(MessagingPort* p) { - scoped_lock bl(m); + boost::lock_guard<boost::mutex> bl(m); ports.erase(p); } }; diff --git a/src/mongo/util/queue.h b/src/mongo/util/queue.h index 07ba57e87ab..7ae46f97325 100644 --- a/src/mongo/util/queue.h +++ b/src/mongo/util/queue.h @@ -56,26 +56,23 @@ namespace mongo { typedef size_t (*getSizeFunc)(const T& t); public: BlockingQueue() : - _lock("BlockingQueue"), _maxSize(std::numeric_limits<std::size_t>::max()), _currentSize(0), _getSize(&_getSizeDefault) {} BlockingQueue(size_t size) : - _lock("BlockingQueue(bounded)"), _maxSize(size), _currentSize(0), _getSize(&_getSizeDefault) {} BlockingQueue(size_t size, getSizeFunc f) : - _lock("BlockingQueue(custom size)"), _maxSize(size), _currentSize(0), _getSize(f) {} void push(T const& t) { - scoped_lock l( _lock ); + boost::unique_lock<boost::mutex> l( _lock ); size_t tSize = _getSize(t); while (_currentSize + tSize > _maxSize) { - _cvNoLongerFull.wait( l.boost() ); + _cvNoLongerFull.wait( l ); } _queue.push( t ); _currentSize += tSize; @@ -83,7 +80,7 @@ namespace mongo { } bool empty() const { - scoped_lock l( _lock ); + boost::lock_guard<boost::mutex> l( _lock ); return _queue.empty(); } @@ -91,7 +88,7 @@ namespace mongo { * The size as measured by the size function. Default to counting each item */ size_t size() const { - scoped_lock l( _lock ); + boost::lock_guard<boost::mutex> l( _lock ); return _currentSize; } @@ -106,19 +103,19 @@ namespace mongo { * The number/count of items in the queue ( _queue.size() ) */ size_t count() const { - scoped_lock l( _lock ); + boost::lock_guard<boost::mutex> l( _lock ); return _queue.size(); } void clear() { - scoped_lock l(_lock); + boost::lock_guard<boost::mutex> l(_lock); _queue = std::queue<T>(); _currentSize = 0; _cvNoLongerFull.notify_one(); } bool tryPop( T & t ) { - scoped_lock l( _lock ); + boost::lock_guard<boost::mutex> l( _lock ); if ( _queue.empty() ) return false; @@ -132,9 +129,9 @@ namespace mongo { T blockingPop() { - scoped_lock l( _lock ); + boost::unique_lock<boost::mutex> l( _lock ); while( _queue.empty() ) - _cvNoLongerEmpty.wait( l.boost() ); + _cvNoLongerEmpty.wait( l ); T t = _queue.front(); _queue.pop(); @@ -158,9 +155,9 @@ namespace mongo { boost::xtime_get(&xt, MONGO_BOOST_TIME_UTC); xt.sec += maxSecondsToWait; - scoped_lock l( _lock ); + boost::unique_lock<boost::mutex> l( _lock ); while( _queue.empty() ) { - if ( ! _cvNoLongerEmpty.timed_wait( l.boost() , xt ) ) + if ( ! _cvNoLongerEmpty.timed_wait( l , xt ) ) return false; } @@ -180,9 +177,9 @@ namespace mongo { boost::xtime_get(&xt, MONGO_BOOST_TIME_UTC); xt.sec += maxSecondsToWait; - scoped_lock l( _lock ); + boost::unique_lock<boost::mutex> l( _lock ); while( _queue.empty() ) { - if ( ! _cvNoLongerEmpty.timed_wait( l.boost() , xt ) ) + if ( ! _cvNoLongerEmpty.timed_wait( l , xt ) ) return false; } @@ -194,7 +191,7 @@ namespace mongo { // only one consumer bool peek(T& t) { - scoped_lock l( _lock ); + boost::unique_lock<boost::mutex> l( _lock ); if (_queue.empty()) { return false; } |