diff options
Diffstat (limited to 'src')
55 files changed, 341 insertions, 241 deletions
diff --git a/src/mongo/client/examples/mongoperf.cpp b/src/mongo/client/examples/mongoperf.cpp index 56a06205485..0e45db2ff4d 100644 --- a/src/mongo/client/examples/mongoperf.cpp +++ b/src/mongo/client/examples/mongoperf.cpp @@ -216,6 +216,7 @@ void go() { syncDelaySecs = options["syncDelay"].numberInt(); if (syncDelaySecs) { stdx::thread t(syncThread); + t.detach(); } } @@ -241,6 +242,7 @@ void go() { while (nthr < wthr && nthr < d) { nthr++; stdx::thread w(workerThread); + w.detach(); } cout << "new thread, total running : " << nthr << endl; d *= 2; diff --git a/src/mongo/client/replica_set_monitor.cpp b/src/mongo/client/replica_set_monitor.cpp index 0c3fc67fe16..6cdc4341920 100644 --- a/src/mongo/client/replica_set_monitor.cpp +++ b/src/mongo/client/replica_set_monitor.cpp @@ -127,7 +127,7 @@ protected: // using it. if (!inShutdown() && !StaticObserver::_destroyingStatics) { stdx::unique_lock<stdx::mutex> sl(_monitorMutex); - _stopRequestedCV.timed_wait(sl, boost::posix_time::seconds(10)); + _stopRequestedCV.wait_for(sl, stdx::chrono::seconds(10)); } while (!inShutdown() && !StaticObserver::_destroyingStatics) { @@ -151,7 +151,7 @@ protected: break; } - _stopRequestedCV.timed_wait(sl, boost::posix_time::seconds(10)); + _stopRequestedCV.wait_for(sl, stdx::chrono::seconds(10)); } } diff --git a/src/mongo/client/scoped_db_conn_test.cpp b/src/mongo/client/scoped_db_conn_test.cpp index 52bfb8241db..bfdc8dab4dc 100644 --- a/src/mongo/client/scoped_db_conn_test.cpp +++ b/src/mongo/client/scoped_db_conn_test.cpp @@ -29,10 +29,8 @@ #include "mongo/platform/basic.h" -#include <mutex> #include <vector> #include <string> -#include <thread> #include "mongo/client/connpool.h" #include "mongo/client/global_conn_pool.h" @@ -40,6 +38,8 @@ #include "mongo/rpc/factory.h" #include "mongo/rpc/reply_builder_interface.h" #include "mongo/rpc/request_interface.h" +#include "mongo/stdx/mutex.h" +#include "mongo/stdx/thread.h" #include "mongo/unittest/unittest.h" #include "mongo/util/fail_point_service.h" #include "mongo/util/log.h" @@ -68,14 +68,14 @@ class OperationContext; namespace { -std::mutex shutDownMutex; +stdx::mutex shutDownMutex; bool shuttingDown = false; } // namespace // Symbols defined to build the binary correctly. bool inShutdown() { - std::lock_guard<std::mutex> sl(shutDownMutex); + stdx::lock_guard<stdx::mutex> sl(shutDownMutex); return shuttingDown; } @@ -87,7 +87,7 @@ DBClientBase* createDirectClient(OperationContext* txn) { void dbexit(ExitCode rc, const char* why) { { - std::lock_guard<std::mutex> sl(shutDownMutex); + stdx::lock_guard<stdx::mutex> sl(shutDownMutex); shuttingDown = true; } @@ -172,12 +172,12 @@ public: options.port = _port; { - std::lock_guard<std::mutex> sl(shutDownMutex); + stdx::lock_guard<stdx::mutex> sl(shutDownMutex); shuttingDown = false; } _server.reset(createServer(options, messsageHandler)); - _serverThread = std::thread(runServer, _server.get()); + _serverThread = stdx::thread(runServer, _server.get()); } /** @@ -189,7 +189,7 @@ public: } { - std::lock_guard<std::mutex> sl(shutDownMutex); + stdx::lock_guard<stdx::mutex> sl(shutDownMutex); shuttingDown = true; } @@ -222,7 +222,7 @@ public: private: const int _port; - std::thread _serverThread; + stdx::thread _serverThread; unique_ptr<MessageServer> _server; }; diff --git a/src/mongo/db/concurrency/lock_state.cpp b/src/mongo/db/concurrency/lock_state.cpp index 008646a586e..3268e2cbac0 100644 --- a/src/mongo/db/concurrency/lock_state.cpp +++ b/src/mongo/db/concurrency/lock_state.cpp @@ -226,7 +226,7 @@ void CondVarLockGrantNotification::clear() { LockResult CondVarLockGrantNotification::wait(unsigned timeoutMs) { stdx::unique_lock<stdx::mutex> lock(_mutex); while (_result == LOCK_INVALID) { - if (boost::cv_status::timeout == _cond.wait_for(lock, Milliseconds(timeoutMs))) { + if (stdx::cv_status::timeout == _cond.wait_for(lock, Milliseconds(timeoutMs))) { // Timeout return LOCK_TIMEOUT; } diff --git a/src/mongo/db/curop_test.cpp b/src/mongo/db/curop_test.cpp index 098ead0674f..aaf0933f484 100644 --- a/src/mongo/db/curop_test.cpp +++ b/src/mongo/db/curop_test.cpp @@ -65,6 +65,7 @@ void timeTrackerSetup() { MONGO_INITIALIZER(CurOpTest)(InitializerContext* context) { stdx::thread t(timeTrackerSetup); + t.detach(); // Wait for listener thread to start tracking time. while (Listener::getElapsedTimeMillis() == 0) { diff --git a/src/mongo/db/instance.cpp b/src/mongo/db/instance.cpp index 257193b53c9..c34daf48d6b 100644 --- a/src/mongo/db/instance.cpp +++ b/src/mongo/db/instance.cpp @@ -1163,6 +1163,7 @@ static void shutdownServer() { /* must do this before unmapping mem or you may get a seg fault */ log(LogComponent::kNetwork) << "shutdown: going to close sockets..." << endl; stdx::thread close_socket_thread(stdx::bind(MessagingPort::closeAllSockets, 0)); + close_socket_thread.detach(); getGlobalServiceContext()->shutdownGlobalStorageEngineCleanly(); } diff --git a/src/mongo/db/log_process_details.cpp b/src/mongo/db/log_process_details.cpp index 9ba6c91299a..777777d7a40 100644 --- a/src/mongo/db/log_process_details.cpp +++ b/src/mongo/db/log_process_details.cpp @@ -44,15 +44,12 @@ namespace mongo { -using std::cout; -using std::endl; - bool is32bit() { return (sizeof(int*) == 4); } void logProcessDetails() { - log() << mongodVersion() << endl; + log() << mongodVersion(); printGitVersion(); printOpenSSLVersion(); printAllocator(); diff --git a/src/mongo/db/range_deleter.cpp b/src/mongo/db/range_deleter.cpp index 036f8e7c4d4..7bb98bbc01f 100644 --- a/src/mongo/db/range_deleter.cpp +++ b/src/mongo/db/range_deleter.cpp @@ -436,7 +436,8 @@ void RangeDeleter::doWork() { { stdx::unique_lock<stdx::mutex> sl(_queueMutex); while (_taskQueue.empty()) { - _taskQueueNotEmptyCV.timed_wait(sl, duration::milliseconds(kNotEmptyTimeoutMillis)); + _taskQueueNotEmptyCV.wait_for(sl, + stdx::chrono::milliseconds(kNotEmptyTimeoutMillis)); if (stopRequested()) { log() << "stopping range deleter worker" << endl; diff --git a/src/mongo/db/range_deleter_test.cpp b/src/mongo/db/range_deleter_test.cpp index 782b7235d60..3db312b7f98 100644 --- a/src/mongo/db/range_deleter_test.cpp +++ b/src/mongo/db/range_deleter_test.cpp @@ -36,8 +36,10 @@ #include "mongo/db/service_context.h" #include "mongo/db/write_concern_options.h" #include "mongo/stdx/functional.h" +#include "mongo/stdx/future.h" #include "mongo/stdx/thread.h" #include "mongo/unittest/unittest.h" +#include "mongo/util/scopeguard.h" namespace { @@ -49,10 +51,11 @@ using mongo::DeletedRange; using mongo::FieldParser; using mongo::KeyRange; using mongo::Notification; +using mongo::OperationContext; using mongo::RangeDeleter; using mongo::RangeDeleterMockEnv; using mongo::RangeDeleterOptions; -using mongo::OperationContext; +using mongo::MakeGuard; namespace stdx = mongo::stdx; @@ -163,13 +166,6 @@ TEST(QueuedDelete, StopWhileWaitingCursor) { ASSERT_FALSE(env->deleteOccured()); } -static void rangeDeleterDeleteNow(RangeDeleter* deleter, - OperationContext* txn, - const RangeDeleterOptions& deleterOptions, - std::string* errMsg) { - deleter->deleteNow(txn, deleterOptions, errMsg); -} - // Should not start delete if the set of cursors that were open when the // deleteNow method is called is still open. TEST(ImmediateDelete, ShouldWaitCursor) { @@ -191,8 +187,16 @@ TEST(ImmediateDelete, ShouldWaitCursor) { RangeDeleterOptions deleterOption( KeyRange(ns, BSON("x" << 0), BSON("x" << 10), BSON("x" << 1))); deleterOption.waitForOpenCursors = true; - stdx::thread deleterThread = stdx::thread( - mongo::stdx::bind(rangeDeleterDeleteNow, &deleter, noTxn, deleterOption, &errMsg)); + + stdx::packaged_task<void()> deleterTask( + [&] { deleter.deleteNow(noTxn, deleterOption, &errMsg); }); + stdx::future<void> deleterFuture = deleterTask.get_future(); + stdx::thread deleterThread(std::move(deleterTask)); + + auto guard = MakeGuard([&] { + deleter.stopWorkers(); + deleterThread.join(); + }); env->waitForNthGetCursor(1u); @@ -206,8 +210,8 @@ TEST(ImmediateDelete, ShouldWaitCursor) { env->addCursorId(ns, 200); env->removeCursorId(ns, 345); - ASSERT_TRUE( - deleterThread.timed_join(boost::posix_time::seconds(MAX_IMMEDIATE_DELETE_WAIT_SECS))); + ASSERT_TRUE(stdx::future_status::ready == + deleterFuture.wait_for(stdx::chrono::seconds(MAX_IMMEDIATE_DELETE_WAIT_SECS))); ASSERT_TRUE(env->deleteOccured()); const DeletedRange deletedChunk(env->getLastDelete()); @@ -216,8 +220,6 @@ TEST(ImmediateDelete, ShouldWaitCursor) { ASSERT_TRUE(deletedChunk.min.equal(BSON("x" << 0))); ASSERT_TRUE(deletedChunk.max.equal(BSON("x" << 10))); ASSERT_TRUE(deletedChunk.shardKeyPattern.equal(BSON("x" << 1))); - - deleter.stopWorkers(); } // Should terminate when stop is requested. @@ -240,8 +242,14 @@ TEST(ImmediateDelete, StopWhileWaitingCursor) { RangeDeleterOptions deleterOption( KeyRange(ns, BSON("x" << 0), BSON("x" << 10), BSON("x" << 1))); deleterOption.waitForOpenCursors = true; - stdx::thread deleterThread = stdx::thread( - mongo::stdx::bind(rangeDeleterDeleteNow, &deleter, noTxn, deleterOption, &errMsg)); + + stdx::packaged_task<void()> deleterTask( + [&] { deleter.deleteNow(noTxn, deleterOption, &errMsg); }); + stdx::future<void> deleterFuture = deleterTask.get_future(); + stdx::thread deleterThread(std::move(deleterTask)); + + auto join_thread_guard = MakeGuard([&] { deleterThread.join(); }); + auto stop_deleter_guard = MakeGuard([&] { deleter.stopWorkers(); }); env->waitForNthGetCursor(1u); @@ -251,10 +259,10 @@ TEST(ImmediateDelete, StopWhileWaitingCursor) { ASSERT_FALSE(env->deleteOccured()); - deleter.stopWorkers(); + stop_deleter_guard.Execute(); - ASSERT_TRUE( - deleterThread.timed_join(boost::posix_time::seconds(MAX_IMMEDIATE_DELETE_WAIT_SECS))); + ASSERT_TRUE(stdx::future_status::ready == + deleterFuture.wait_for(stdx::chrono::seconds(MAX_IMMEDIATE_DELETE_WAIT_SECS))); ASSERT_FALSE(env->deleteOccured()); } diff --git a/src/mongo/db/repl/data_replicator.cpp b/src/mongo/db/repl/data_replicator.cpp index 11c55208268..feb2ec711b2 100644 --- a/src/mongo/db/repl/data_replicator.cpp +++ b/src/mongo/db/repl/data_replicator.cpp @@ -33,7 +33,6 @@ #include "data_replicator.h" #include <algorithm> -#include <thread> #include "mongo/base/status.h" #include "mongo/client/query_fetcher.h" diff --git a/src/mongo/db/repl/data_replicator_test.cpp b/src/mongo/db/repl/data_replicator_test.cpp index 84cd64c1866..661c97d6e57 100644 --- a/src/mongo/db/repl/data_replicator_test.cpp +++ b/src/mongo/db/repl/data_replicator_test.cpp @@ -356,7 +356,7 @@ protected: } void verifySync(Status s = Status::OK()) { - verifySync(_isbr->getResult().getStatus().code()); + ASSERT_EQ(_isbr->getResult().getStatus(), s) << "status objects differ"; } void verifySync(ErrorCodes::Error code) { diff --git a/src/mongo/db/repl/master_slave.cpp b/src/mongo/db/repl/master_slave.cpp index 074a7fcbe77..7a9eea27a98 100644 --- a/src/mongo/db/repl/master_slave.cpp +++ b/src/mongo/db/repl/master_slave.cpp @@ -1348,12 +1348,14 @@ void startMasterSlave(OperationContext* txn) { verify(replSettings.slave == SimpleSlave); LOG(1) << "slave=true" << endl; stdx::thread repl_thread(replSlaveThread); + repl_thread.detach(); } if (replSettings.master) { LOG(1) << "master=true" << endl; createOplog(txn); stdx::thread t(replMasterThread); + t.detach(); } if (replSettings.fastsync) { diff --git a/src/mongo/db/repl/oplog.cpp b/src/mongo/db/repl/oplog.cpp index 213cb9f38a6..1f7334e5481 100644 --- a/src/mongo/db/repl/oplog.cpp +++ b/src/mongo/db/repl/oplog.cpp @@ -824,7 +824,7 @@ void waitUpToOneSecondForTimestampChange(const Timestamp& referenceTime) { stdx::unique_lock<stdx::mutex> lk(newOpMutex); while (referenceTime == getLastSetTimestamp()) { - if (!newTimestampNotifier.timed_wait(lk, boost::posix_time::seconds(1))) + if (stdx::cv_status::timeout == newTimestampNotifier.wait_for(lk, stdx::chrono::seconds(1))) return; } } diff --git a/src/mongo/db/repl/replication_coordinator_impl_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_test.cpp index de1e0eb1e05..0f811630297 100644 --- a/src/mongo/db/repl/replication_coordinator_impl_test.cpp +++ b/src/mongo/db/repl/replication_coordinator_impl_test.cpp @@ -30,7 +30,6 @@ #include "mongo/platform/basic.h" -#include <future> #include <iostream> #include <memory> #include <set> @@ -57,6 +56,7 @@ #include "mongo/db/write_concern_options.h" #include "mongo/executor/network_interface_mock.h" #include "mongo/stdx/functional.h" +#include "mongo/stdx/future.h" #include "mongo/stdx/thread.h" #include "mongo/unittest/unittest.h" #include "mongo/util/assert_util.h" @@ -1872,7 +1872,6 @@ TEST_F(ReplCoordTest, AwaitReplicationReconfigNodeCountExceedsNumberOfNodes) { getNet()->exitNetwork(); reconfigThread.join(); ASSERT_OK(status); - std::cout << "asdf" << std::endl; // writeconcern feasability should be reevaluated and an error should be returned ReplicationCoordinator::StatusAndDuration statusAndDur = awaiter.getResult(); @@ -2162,11 +2161,11 @@ TEST_F(ReplCoordTest, ReadAfterDeferredGreaterOpTime) { getReplCoord()->setMyLastOptime(OpTimeWithTermZero(0, 0)); - auto pseudoLogOp = std::async(std::launch::async, - [this]() { - // Not guaranteed to be scheduled after waitUnitl blocks... - getReplCoord()->setMyLastOptime(OpTimeWithTermZero(200, 0)); - }); + auto pseudoLogOp = stdx::async(stdx::launch::async, + [this]() { + // Not guaranteed to be scheduled after waitUntil blocks... + getReplCoord()->setMyLastOptime(OpTimeWithTermZero(200, 0)); + }); auto result = getReplCoord()->waitUntilOpTime(&txn, ReadAfterOpTimeArgs(OpTimeWithTermZero(100, 0))); @@ -2189,11 +2188,11 @@ TEST_F(ReplCoordTest, ReadAfterDeferredEqualOpTime) { OpTimeWithTermZero opTimeToWait(100, 0); - auto pseudoLogOp = std::async(std::launch::async, - [this, &opTimeToWait]() { - // Not guaranteed to be scheduled after waitUnitl blocks... - getReplCoord()->setMyLastOptime(opTimeToWait); - }); + auto pseudoLogOp = stdx::async(stdx::launch::async, + [this, &opTimeToWait]() { + // Not guaranteed to be scheduled after waitUntil blocks... + getReplCoord()->setMyLastOptime(opTimeToWait); + }); auto result = getReplCoord()->waitUntilOpTime(&txn, ReadAfterOpTimeArgs(opTimeToWait)); pseudoLogOp.get(); diff --git a/src/mongo/db/repl/replication_executor.cpp b/src/mongo/db/repl/replication_executor.cpp index 30c0b0ef733..0c366836bb2 100644 --- a/src/mongo/db/repl/replication_executor.cpp +++ b/src/mongo/db/repl/replication_executor.cpp @@ -33,7 +33,6 @@ #include "mongo/db/repl/replication_executor.h" #include <limits> -#include <thread> #include "mongo/db/repl/database_task.h" #include "mongo/db/repl/storage_interface.h" diff --git a/src/mongo/db/repl/snapshot_thread.h b/src/mongo/db/repl/snapshot_thread.h index 71aeede08d8..c657ee0d554 100644 --- a/src/mongo/db/repl/snapshot_thread.h +++ b/src/mongo/db/repl/snapshot_thread.h @@ -28,11 +28,10 @@ #pragma once -#include <functional> - #include "mongo/base/disallow_copying.h" #include "mongo/db/service_context.h" #include "mongo/db/storage/snapshot_manager.h" +#include "mongo/stdx/functional.h" #include "mongo/stdx/thread.h" namespace mongo { @@ -48,7 +47,7 @@ class SnapshotThread { MONGO_DISALLOW_COPYING(SnapshotThread); public: - using Callback = std::function<void(SnapshotName)>; + using Callback = stdx::function<void(SnapshotName)>; /** * Starts a thread to take periodic snapshots if supported by the storageEngine. diff --git a/src/mongo/db/storage/mmap_v1/dur.cpp b/src/mongo/db/storage/mmap_v1/dur.cpp index a17a7a80d51..359e231f1b3 100644 --- a/src/mongo/db/storage/mmap_v1/dur.cpp +++ b/src/mongo/db/storage/mmap_v1/dur.cpp @@ -687,7 +687,7 @@ static void durThread() { stdx::unique_lock<stdx::mutex> lock(flushMutex); for (unsigned i = 0; i <= 2; i++) { - if (boost::cv_status::no_timeout == + if (stdx::cv_status::no_timeout == flushRequested.wait_for(lock, Milliseconds(oneThird))) { // Someone forced a flush break; diff --git a/src/mongo/db/storage/mmap_v1/file_allocator.cpp b/src/mongo/db/storage/mmap_v1/file_allocator.cpp index f033e1c6a5a..04fa0e6f420 100644 --- a/src/mongo/db/storage/mmap_v1/file_allocator.cpp +++ b/src/mongo/db/storage/mmap_v1/file_allocator.cpp @@ -129,6 +129,7 @@ FileAllocator::FileAllocator() : _failed() {} void FileAllocator::start() { stdx::thread t(stdx::bind(&FileAllocator::run, this)); + t.detach(); } void FileAllocator::requestAllocation(const string& name, long& size) { diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp index 536eb8c2ac3..8611347b206 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp @@ -620,7 +620,7 @@ int64_t WiredTigerRecordStore::cappedDeleteAsNeeded(OperationContext* txn, // Don't wait forever: we're in a transaction, we could block eviction. if (!lock.try_lock()) { Date_t before = Date_t::now(); - (void)lock.timed_lock(boost::posix_time::millisec(200)); + (void)lock.try_lock_for(stdx::chrono::milliseconds(200)); stdx::chrono::milliseconds delay = Date_t::now() - before; _cappedSleep.fetchAndAdd(1); _cappedSleepMS.fetchAndAdd(delay.count()); @@ -635,7 +635,7 @@ int64_t WiredTigerRecordStore::cappedDeleteAsNeeded(OperationContext* txn, // Don't wait forever: we're in a transaction, we could block eviction. Date_t before = Date_t::now(); - bool gotLock = lock.timed_lock(boost::posix_time::millisec(200)); + bool gotLock = lock.try_lock_for(stdx::chrono::milliseconds(200)); stdx::chrono::milliseconds delay = Date_t::now() - before; _cappedSleep.fetchAndAdd(1); _cappedSleepMS.fetchAndAdd(delay.count()); @@ -823,7 +823,7 @@ bool WiredTigerRecordStore::isCappedHidden(const RecordId& loc) const { } RecordId WiredTigerRecordStore::lowestCappedHiddenRecord() const { - boost::lock_guard<boost::mutex> lk(_uncommittedDiskLocsMutex); + stdx::lock_guard<stdx::mutex> lk(_uncommittedDiskLocsMutex); return _uncommittedDiskLocs.empty() ? RecordId() : _uncommittedDiskLocs.front(); } diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp index 1d45be06a97..d08e6c6fbc9 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp @@ -62,7 +62,7 @@ struct WaitUntilDurableData { stdx::unique_lock<stdx::mutex> lk(mutex); long long start = lastSyncTime; numWaitingForSync.fetchAndAdd(1); - condvar.timed_wait(lk, boost::posix_time::milliseconds(50)); + condvar.wait_for(lk, stdx::chrono::milliseconds(50)); numWaitingForSync.fetchAndAdd(-1); return lastSyncTime > start; } diff --git a/src/mongo/dbtests/threadedtests.cpp b/src/mongo/dbtests/threadedtests.cpp index 76c0d5b8255..1ad45c337bf 100644 --- a/src/mongo/dbtests/threadedtests.cpp +++ b/src/mongo/dbtests/threadedtests.cpp @@ -33,6 +33,7 @@ #include "mongo/platform/basic.h" +#include <boost/thread/barrier.hpp> #include <boost/version.hpp> #include <iostream> diff --git a/src/mongo/executor/network_interface_asio.cpp b/src/mongo/executor/network_interface_asio.cpp index 3c238ed83c4..459c8b36606 100644 --- a/src/mongo/executor/network_interface_asio.cpp +++ b/src/mongo/executor/network_interface_asio.cpp @@ -335,7 +335,7 @@ void NetworkInterfaceASIO::_completeOperation(AsyncOp* op) { } void NetworkInterfaceASIO::startup() { - _serviceRunner = std::thread([this]() { + _serviceRunner = stdx::thread([this]() { asio::io_service::work work(_io_service); _io_service.run(); }); @@ -411,7 +411,7 @@ void NetworkInterfaceASIO::startCommand(const TaskExecutor::CallbackHandle& cbHa } // connect in a separate thread to avoid blocking the rest of the system - std::thread t([this, op]() { + stdx::thread t([this, op]() { try { // The call to connect() will throw if: // - we cannot get a new connection from the pool diff --git a/src/mongo/executor/network_interface_asio.h b/src/mongo/executor/network_interface_asio.h index 8c179c7f1e1..8d2e9ba91cd 100644 --- a/src/mongo/executor/network_interface_asio.h +++ b/src/mongo/executor/network_interface_asio.h @@ -155,7 +155,7 @@ private: void _signalWorkAvailable_inlock(); asio::io_service _io_service; - std::thread _serviceRunner; + stdx::thread _serviceRunner; std::atomic<State> _state; diff --git a/src/mongo/executor/network_test_env.h b/src/mongo/executor/network_test_env.h index 5606d71d504..e7d56151ebd 100644 --- a/src/mongo/executor/network_test_env.h +++ b/src/mongo/executor/network_test_env.h @@ -28,13 +28,14 @@ #pragma once -#include <functional> -#include <future> #include <type_traits> #include <vector> #include "mongo/db/repl/replication_executor.h" #include "mongo/executor/network_interface_mock.h" +#include "mongo/stdx/thread.h" +#include "mongo/stdx/functional.h" +#include "mongo/stdx/future.h" namespace mongo { @@ -62,7 +63,7 @@ public: template <class T> class FutureHandle { public: - FutureHandle<T>(std::future<T> future, + FutureHandle<T>(stdx::future<T> future, executor::TaskExecutor* executor, executor::NetworkInterfaceMock* network) : _future(std::move(future)), _executor(executor), _network(network) {} @@ -100,8 +101,8 @@ public: } template <class Rep, class Period> - std::future_status wait_for( - const std::chrono::duration<Rep, Period>& timeout_duration) const { + stdx::future_status wait_for( + const stdx::chrono::duration<Rep, Period>& timeout_duration) const { return _future.wait_for(timeout_duration); } @@ -114,7 +115,7 @@ public: } private: - std::future<T> _future; + stdx::future<T> _future; executor::TaskExecutor* _executor; executor::NetworkInterfaceMock* _network; }; @@ -129,16 +130,16 @@ public: */ template <typename Lambda> FutureHandle<typename std::result_of<Lambda()>::type> launchAsync(Lambda&& func) const { - auto future = async(std::launch::async, std::forward<Lambda>(func)); + auto future = async(stdx::launch::async, std::forward<Lambda>(func)); return NetworkTestEnv::FutureHandle<typename std::result_of<Lambda()>::type>{ std::move(future), _executor, _mockNetwork}; } - using OnCommandFunction = std::function<StatusWith<BSONObj>(const RemoteCommandRequest&)>; + using OnCommandFunction = stdx::function<StatusWith<BSONObj>(const RemoteCommandRequest&)>; using OnFindCommandFunction = - std::function<StatusWith<std::vector<BSONObj>>(const RemoteCommandRequest&)>; + stdx::function<StatusWith<std::vector<BSONObj>>(const RemoteCommandRequest&)>; /** * Create a new environment based on the given network. diff --git a/src/mongo/logger/logstream_builder.h b/src/mongo/logger/logstream_builder.h index 3cf67ea75d5..275ce871bdd 100644 --- a/src/mongo/logger/logstream_builder.h +++ b/src/mongo/logger/logstream_builder.h @@ -192,7 +192,10 @@ public: template <typename Rep, typename Period> LogstreamBuilder& operator<<(stdx::chrono::duration<Rep, Period> d) { - stream() << d; + // We can't rely on ADL to find our custom stream out class, + // since neither the class (ostream) nor the argument are in + // our namespace. Just manually invoke + mongo::operator<<(stream(), d); return *this; } diff --git a/src/mongo/logger/rotatable_file_writer.h b/src/mongo/logger/rotatable_file_writer.h index b20fb818a9f..06b254b7ef5 100644 --- a/src/mongo/logger/rotatable_file_writer.h +++ b/src/mongo/logger/rotatable_file_writer.h @@ -27,6 +27,8 @@ #pragma once +#include <memory> +#include <ostream> #include <string> #include "mongo/base/disallow_copying.h" diff --git a/src/mongo/s/catalog/catalog_cache.h b/src/mongo/s/catalog/catalog_cache.h index a138c793c64..2547da29960 100644 --- a/src/mongo/s/catalog/catalog_cache.h +++ b/src/mongo/s/catalog/catalog_cache.h @@ -29,6 +29,7 @@ #pragma once #include <map> +#include <memory> #include <string> #include "mongo/base/disallow_copying.h" diff --git a/src/mongo/s/catalog/dist_lock_catalog_impl_test.cpp b/src/mongo/s/catalog/dist_lock_catalog_impl_test.cpp index c95c57c9269..a2f17bdfc60 100644 --- a/src/mongo/s/catalog/dist_lock_catalog_impl_test.cpp +++ b/src/mongo/s/catalog/dist_lock_catalog_impl_test.cpp @@ -46,6 +46,7 @@ #include "mongo/s/client/shard_registry.h" #include "mongo/s/type_lockpings.h" #include "mongo/s/type_locks.h" +#include "mongo/stdx/future.h" #include "mongo/stdx/memory.h" #include "mongo/stdx/thread.h" #include "mongo/unittest/unittest.h" diff --git a/src/mongo/s/catalog/legacy/catalog_manager_legacy.cpp b/src/mongo/s/catalog/legacy/catalog_manager_legacy.cpp index 7711be835a4..0db9a2ea5d4 100644 --- a/src/mongo/s/catalog/legacy/catalog_manager_legacy.cpp +++ b/src/mongo/s/catalog/legacy/catalog_manager_legacy.cpp @@ -417,7 +417,10 @@ void CatalogManagerLegacy::shutDown() { _inShutdown = true; _consistencyCheckerCV.notify_one(); } - _consistencyCheckerThread.join(); + + // Only try to join the thread if we actually started it. + if (_consistencyCheckerThread.joinable()) + _consistencyCheckerThread.join(); invariant(_distLockManager); _distLockManager->shutDown(); diff --git a/src/mongo/s/catalog/replset/catalog_manager_replica_set.cpp b/src/mongo/s/catalog/replset/catalog_manager_replica_set.cpp index 795b822e0a2..ab825acd12c 100644 --- a/src/mongo/s/catalog/replset/catalog_manager_replica_set.cpp +++ b/src/mongo/s/catalog/replset/catalog_manager_replica_set.cpp @@ -123,7 +123,7 @@ ConnectionString CatalogManagerReplicaSet::connectionString() const { void CatalogManagerReplicaSet::shutDown() { LOG(1) << "CatalogManagerReplicaSet::shutDown() called."; { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); _inShutdown = true; } diff --git a/src/mongo/s/catalog/replset/catalog_manager_replica_set.h b/src/mongo/s/catalog/replset/catalog_manager_replica_set.h index b66432fdd0f..6409fe2f619 100644 --- a/src/mongo/s/catalog/replset/catalog_manager_replica_set.h +++ b/src/mongo/s/catalog/replset/catalog_manager_replica_set.h @@ -29,7 +29,6 @@ #pragma once #include <memory> -#include <mutex> #include <string> #include <vector> @@ -37,6 +36,7 @@ #include "mongo/client/connection_string.h" #include "mongo/platform/atomic_word.h" #include "mongo/s/catalog/catalog_manager.h" +#include "mongo/stdx/mutex.h" namespace mongo { @@ -162,7 +162,7 @@ private: AtomicInt32 _changeLogCollectionCreated; // protects _inShutdown - std::mutex _mutex; + stdx::mutex _mutex; // True if shutDown() has been called. False, otherwise. bool _inShutdown = false; diff --git a/src/mongo/s/catalog/replset/catalog_manager_replica_set_log_action_test.cpp b/src/mongo/s/catalog/replset/catalog_manager_replica_set_log_action_test.cpp index 9d3d5d688f4..727e942bfa0 100644 --- a/src/mongo/s/catalog/replset/catalog_manager_replica_set_log_action_test.cpp +++ b/src/mongo/s/catalog/replset/catalog_manager_replica_set_log_action_test.cpp @@ -30,8 +30,6 @@ #include "mongo/platform/basic.h" -#include <chrono> - #include "mongo/client/remote_command_targeter_mock.h" #include "mongo/db/commands.h" #include "mongo/executor/network_interface_mock.h" @@ -42,6 +40,8 @@ #include "mongo/s/client/shard_registry.h" #include "mongo/s/write_ops/batched_command_request.h" #include "mongo/s/write_ops/batched_command_response.h" +#include "mongo/stdx/chrono.h" +#include "mongo/stdx/future.h" #include "mongo/util/log.h" namespace mongo { @@ -51,7 +51,7 @@ using executor::NetworkInterfaceMock; using executor::TaskExecutor; using unittest::assertGet; -static const std::chrono::seconds kFutureTimeout{5}; +static const stdx::chrono::seconds kFutureTimeout{5}; class LogActionTest : public CatalogManagerReplSetTestFixture { public: diff --git a/src/mongo/s/catalog/replset/catalog_manager_replica_set_log_change_test.cpp b/src/mongo/s/catalog/replset/catalog_manager_replica_set_log_change_test.cpp index 22a83224f28..86d175b63e1 100644 --- a/src/mongo/s/catalog/replset/catalog_manager_replica_set_log_change_test.cpp +++ b/src/mongo/s/catalog/replset/catalog_manager_replica_set_log_change_test.cpp @@ -30,8 +30,6 @@ #include "mongo/platform/basic.h" -#include <chrono> -#include <future> #include <vector> #include "mongo/client/remote_command_targeter_mock.h" @@ -44,6 +42,8 @@ #include "mongo/s/client/shard_registry.h" #include "mongo/s/write_ops/batched_command_request.h" #include "mongo/s/write_ops/batched_command_response.h" +#include "mongo/stdx/chrono.h" +#include "mongo/stdx/future.h" #include "mongo/util/log.h" #include "mongo/util/mongoutils/str.h" #include "mongo/util/text.h" @@ -53,10 +53,10 @@ namespace { using executor::NetworkInterfaceMock; using executor::TaskExecutor; -using std::async; +using stdx::async; using unittest::assertGet; -static const std::chrono::seconds kFutureTimeout{5}; +static const stdx::chrono::seconds kFutureTimeout{5}; class LogChangeTest : public CatalogManagerReplSetTestFixture { public: @@ -129,7 +129,7 @@ TEST_F(LogChangeTest, LogChangeNoRetryAfterSuccessfulCreate) { expectedChangeLog.setWhat("moved a chunk"); expectedChangeLog.setDetails(BSON("min" << 3 << "max" << 4)); - auto future = async(std::launch::async, + auto future = async(stdx::launch::async, [this, &expectedChangeLog] { catalogManager()->logChange(expectedChangeLog.getClientAddr(), expectedChangeLog.getWhat(), @@ -144,7 +144,7 @@ TEST_F(LogChangeTest, LogChangeNoRetryAfterSuccessfulCreate) { future.wait_for(kFutureTimeout); // Now log another change and confirm that we don't re-attempt to create the collection - future = async(std::launch::async, + future = async(stdx::launch::async, [this, &expectedChangeLog] { catalogManager()->logChange(expectedChangeLog.getClientAddr(), expectedChangeLog.getWhat(), @@ -171,7 +171,7 @@ TEST_F(LogChangeTest, LogActionNoRetryCreateIfAlreadyExists) { expectedChangeLog.setWhat("moved a chunk"); expectedChangeLog.setDetails(BSON("min" << 3 << "max" << 4)); - auto future = async(std::launch::async, + auto future = async(stdx::launch::async, [this, &expectedChangeLog] { catalogManager()->logChange(expectedChangeLog.getClientAddr(), expectedChangeLog.getWhat(), @@ -189,7 +189,7 @@ TEST_F(LogChangeTest, LogActionNoRetryCreateIfAlreadyExists) { future.wait_for(kFutureTimeout); // Now log another change and confirm that we don't re-attempt to create the collection - future = async(std::launch::async, + future = async(stdx::launch::async, [this, &expectedChangeLog] { catalogManager()->logChange(expectedChangeLog.getClientAddr(), expectedChangeLog.getWhat(), @@ -216,7 +216,7 @@ TEST_F(LogChangeTest, LogActionCreateFailure) { expectedChangeLog.setWhat("moved a chunk"); expectedChangeLog.setDetails(BSON("min" << 3 << "max" << 4)); - auto future = async(std::launch::async, + auto future = async(stdx::launch::async, [this, &expectedChangeLog] { catalogManager()->logChange(expectedChangeLog.getClientAddr(), expectedChangeLog.getWhat(), @@ -233,7 +233,7 @@ TEST_F(LogChangeTest, LogActionCreateFailure) { future.wait_for(kFutureTimeout); // Now log another change and confirm that we *do* attempt to create the collection - future = async(std::launch::async, + future = async(stdx::launch::async, [this, &expectedChangeLog] { catalogManager()->logChange(expectedChangeLog.getClientAddr(), expectedChangeLog.getWhat(), diff --git a/src/mongo/s/catalog/replset/catalog_manager_replica_set_test.cpp b/src/mongo/s/catalog/replset/catalog_manager_replica_set_test.cpp index 07da0c6d6a0..36b7a3b85bd 100644 --- a/src/mongo/s/catalog/replset/catalog_manager_replica_set_test.cpp +++ b/src/mongo/s/catalog/replset/catalog_manager_replica_set_test.cpp @@ -30,8 +30,6 @@ #include "mongo/platform/basic.h" -#include <chrono> - #include "mongo/client/remote_command_targeter_mock.h" #include "mongo/db/commands.h" #include "mongo/db/query/lite_parsed_query.h" @@ -52,6 +50,8 @@ #include "mongo/s/write_ops/batched_command_response.h" #include "mongo/s/write_ops/batched_insert_request.h" #include "mongo/s/write_ops/batched_update_request.h" +#include "mongo/stdx/chrono.h" +#include "mongo/stdx/future.h" #include "mongo/util/log.h" namespace mongo { @@ -64,7 +64,7 @@ using std::vector; using stdx::chrono::milliseconds; using unittest::assertGet; -static const std::chrono::seconds kFutureTimeout{5}; +static const stdx::chrono::seconds kFutureTimeout{5}; TEST_F(CatalogManagerReplSetTestFixture, GetCollectionExisting) { RemoteCommandTargeterMock* targeter = @@ -1388,7 +1388,7 @@ TEST_F(CatalogManagerReplSetTestFixture, ApplyChunkOpsDeprecated) { << BSON("precondition2" << "second precondition")); - auto future = async(std::launch::async, + auto future = async(stdx::launch::async, [this, updateOps, preCondition] { auto status = catalogManager()->applyChunkOpsDeprecated(updateOps, preCondition); @@ -1421,7 +1421,7 @@ TEST_F(CatalogManagerReplSetTestFixture, ApplyChunkOpsDeprecatedCommandFailed) { << BSON("precondition2" << "second precondition")); - auto future = async(std::launch::async, + auto future = async(stdx::launch::async, [this, updateOps, preCondition] { auto status = catalogManager()->applyChunkOpsDeprecated(updateOps, preCondition); diff --git a/src/mongo/s/catalog/replset/replset_dist_lock_manager.cpp b/src/mongo/s/catalog/replset/replset_dist_lock_manager.cpp index d057402115c..90f8288c3db 100644 --- a/src/mongo/s/catalog/replset/replset_dist_lock_manager.cpp +++ b/src/mongo/s/catalog/replset/replset_dist_lock_manager.cpp @@ -30,8 +30,6 @@ #include "mongo/platform/basic.h" -#include <chrono> - #include "mongo/s/catalog/replset/replset_dist_lock_manager.h" #include "mongo/base/status.h" @@ -40,6 +38,7 @@ #include "mongo/s/catalog/dist_lock_catalog.h" #include "mongo/s/type_lockpings.h" #include "mongo/s/type_locks.h" +#include "mongo/stdx/chrono.h" #include "mongo/stdx/memory.h" #include "mongo/util/concurrency/thread_name.h" #include "mongo/util/log.h" @@ -51,7 +50,7 @@ namespace mongo { using std::string; using std::unique_ptr; using stdx::chrono::milliseconds; -using std::chrono::duration_cast; +using stdx::chrono::duration_cast; ReplSetDistLockManager::ReplSetDistLockManager(ServiceContext* globalContext, StringData processID, diff --git a/src/mongo/s/client/shard_registry.cpp b/src/mongo/s/client/shard_registry.cpp index 158fd48013b..830354b7867 100644 --- a/src/mongo/s/client/shard_registry.cpp +++ b/src/mongo/s/client/shard_registry.cpp @@ -68,7 +68,7 @@ ShardRegistry::ShardRegistry(std::unique_ptr<RemoteCommandTargeterFactory> targe _network(network), _catalogManager(catalogManager) { // add config shard registry entry so know it's always there - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); _addConfigShard_inlock(); } @@ -92,7 +92,7 @@ void ShardRegistry::reload() { LOG(1) << "found " << numShards << " shards listed on config server(s)"; - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); _lookup.clear(); _rsLookup.clear(); @@ -125,14 +125,14 @@ shared_ptr<Shard> ShardRegistry::getShard(const ShardId& shardId) { } shared_ptr<Shard> ShardRegistry::lookupRSName(const string& name) const { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); ShardMap::const_iterator i = _rsLookup.find(name); return (i == _rsLookup.end()) ? nullptr : i->second; } void ShardRegistry::remove(const ShardId& id) { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); for (ShardMap::iterator i = _lookup.begin(); i != _lookup.end();) { shared_ptr<Shard> s = i->second; @@ -157,7 +157,7 @@ void ShardRegistry::getAllShardIds(vector<ShardId>* all) const { std::set<string> seen; { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); for (ShardMap::const_iterator i = _lookup.begin(); i != _lookup.end(); ++i) { const shared_ptr<Shard>& s = i->second; if (s->getId() == "config") { @@ -177,7 +177,7 @@ void ShardRegistry::getAllShardIds(vector<ShardId>* all) const { void ShardRegistry::toBSON(BSONObjBuilder* result) { BSONObjBuilder b(_lookup.size() + 50); - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); for (ShardMap::const_iterator i = _lookup.begin(); i != _lookup.end(); ++i) { b.append(i->first, i->second->getConnString().toString()); @@ -242,7 +242,7 @@ void ShardRegistry::_addShard_inlock(const ShardType& shardType) { } shared_ptr<Shard> ShardRegistry::_findUsingLookUp(const ShardId& shardId) { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); ShardMap::iterator it = _lookup.find(shardId); if (it != _lookup.end()) { return it->second; diff --git a/src/mongo/s/client/shard_registry.h b/src/mongo/s/client/shard_registry.h index 5bd91b42098..a5fd0366049 100644 --- a/src/mongo/s/client/shard_registry.h +++ b/src/mongo/s/client/shard_registry.h @@ -30,12 +30,12 @@ #include <boost/optional.hpp> #include <memory> -#include <mutex> #include <string> #include <vector> #include "mongo/base/disallow_copying.h" #include "mongo/s/client/shard.h" +#include "mongo/stdx/mutex.h" namespace mongo { @@ -172,7 +172,7 @@ private: CatalogManager* const _catalogManager; // Protects the maps below - mutable std::mutex _mutex; + mutable stdx::mutex _mutex; // Map of both shardName -> Shard and hostName -> Shard ShardMap _lookup; diff --git a/src/mongo/s/d_migrate.cpp b/src/mongo/s/d_migrate.cpp index 6054a8cc32f..f8266c05db5 100644 --- a/src/mongo/s/d_migrate.cpp +++ b/src/mongo/s/d_migrate.cpp @@ -31,12 +31,8 @@ #include "mongo/platform/basic.h" #include <algorithm> -#include <chrono> -#include <condition_variable> #include <map> -#include <mutex> #include <string> -#include <thread> #include <vector> #include "mongo/client/connpool.h" @@ -55,7 +51,6 @@ #include "mongo/db/dbhelpers.h" #include "mongo/db/exec/plan_stage.h" #include "mongo/db/field_parser.h" -#include "mongo/db/service_context.h" #include "mongo/db/hasher.h" #include "mongo/db/jsobj.h" #include "mongo/db/namespace_string.h" @@ -67,21 +62,26 @@ #include "mongo/db/range_deleter_service.h" #include "mongo/db/repl/repl_client_info.h" #include "mongo/db/repl/replication_coordinator_global.h" +#include "mongo/db/service_context.h" #include "mongo/db/storage/mmap_v1/dur.h" #include "mongo/db/write_concern.h" #include "mongo/logger/ramlog.h" #include "mongo/s/catalog/catalog_manager.h" +#include "mongo/s/catalog/dist_lock_manager.h" #include "mongo/s/catalog/type_chunk.h" #include "mongo/s/chunk.h" #include "mongo/s/chunk_version.h" -#include "mongo/s/config.h" -#include "mongo/s/d_state.h" -#include "mongo/s/catalog/dist_lock_manager.h" #include "mongo/s/client/shard.h" #include "mongo/s/client/shard_registry.h" +#include "mongo/s/config.h" +#include "mongo/s/d_state.h" #include "mongo/s/grid.h" #include "mongo/s/shard_key_pattern.h" +#include "mongo/stdx/chrono.h" +#include "mongo/stdx/condition_variable.h" #include "mongo/stdx/memory.h" +#include "mongo/stdx/mutex.h" +#include "mongo/stdx/thread.h" #include "mongo/util/assert_util.h" #include "mongo/util/elapsed_tracker.h" #include "mongo/util/exit.h" @@ -98,7 +98,7 @@ namespace mongo { -using namespace std::chrono; +using namespace stdx::chrono; using std::list; using std::set; using std::string; @@ -194,7 +194,7 @@ public: CurOp* op = CurOp::get(_txn); { - std::lock_guard<Client> lk(*_txn->getClient()); + stdx::lock_guard<Client> lk(*_txn->getClient()); op->setMessage_inlock(s.c_str()); } @@ -266,7 +266,7 @@ public: // Get global shared to synchronize with logOp. Also see comments in the class // members declaration for more details. Lock::GlobalRead globalShared(txn->lockState()); - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); if (_active) { return false; @@ -283,7 +283,7 @@ public: _active = true; - std::lock_guard<std::mutex> tLock(_cloneLocsMutex); + stdx::lock_guard<stdx::mutex> tLock(_cloneLocsMutex); verify(_cloneLocs.size() == 0); return true; @@ -296,7 +296,7 @@ public: // Get global shared to synchronize with logOp. Also see comments in the class // members declaration for more details. Lock::GlobalRead globalShared(txn->lockState()); - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); _active = false; _deleteNotifyExec.reset(NULL); @@ -307,7 +307,7 @@ public: _reload.clear(); _memoryUsed = 0; - std::lock_guard<std::mutex> cloneLock(_cloneLocsMutex); + stdx::lock_guard<stdx::mutex> cloneLock(_cloneLocsMutex); _cloneLocs.clear(); } @@ -434,7 +434,7 @@ public: { AutoGetCollectionForRead ctx(txn, getNS()); - std::lock_guard<std::mutex> sl(_mutex); + stdx::lock_guard<stdx::mutex> sl(_mutex); if (!_active) { errmsg = "no active migration!"; return false; @@ -493,7 +493,7 @@ public: // 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. - std::lock_guard<std::mutex> sl(_mutex); + stdx::lock_guard<stdx::mutex> sl(_mutex); invariant(_deleteNotifyExec.get() == NULL); unique_ptr<WorkingSet> ws = stdx::make_unique<WorkingSet>(); @@ -540,7 +540,7 @@ public: RecordId dl; while (PlanExecutor::ADVANCED == exec->getNext(NULL, &dl)) { if (!isLargeChunk) { - std::lock_guard<std::mutex> lk(_cloneLocsMutex); + stdx::lock_guard<stdx::mutex> lk(_cloneLocsMutex); _cloneLocs.insert(dl); } @@ -553,7 +553,7 @@ public: exec.reset(); if (isLargeChunk) { - std::lock_guard<std::mutex> sl(_mutex); + stdx::lock_guard<stdx::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 << ". Found " << recCount @@ -579,7 +579,7 @@ public: { AutoGetCollectionForRead ctx(txn, getNS()); - std::lock_guard<std::mutex> sl(_mutex); + stdx::lock_guard<stdx::mutex> sl(_mutex); if (!_active) { errmsg = "not active"; return false; @@ -601,7 +601,7 @@ public: while (!isBufferFilled) { AutoGetCollectionForRead ctx(txn, getNS()); - std::lock_guard<std::mutex> sl(_mutex); + stdx::lock_guard<stdx::mutex> sl(_mutex); if (!_active) { errmsg = "not active"; return false; @@ -616,7 +616,7 @@ public: return false; } - std::lock_guard<std::mutex> lk(_cloneLocsMutex); + stdx::lock_guard<stdx::mutex> lk(_cloneLocsMutex); set<RecordId>::iterator cloneLocsIter = _cloneLocs.begin(); for (; cloneLocsIter != _cloneLocs.end(); ++cloneLocsIter) { if (tracker.intervalHasElapsed()) // should I yield? @@ -659,33 +659,33 @@ public: // that check only works for non-mmapv1 engines, and this is needed // for mmapv1. - std::lock_guard<std::mutex> lk(_cloneLocsMutex); + stdx::lock_guard<stdx::mutex> lk(_cloneLocsMutex); _cloneLocs.erase(dl); } std::size_t cloneLocsRemaining() { - std::lock_guard<std::mutex> lk(_cloneLocsMutex); + stdx::lock_guard<stdx::mutex> lk(_cloneLocsMutex); return _cloneLocs.size(); } long long mbUsed() const { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); return _memoryUsed / (1024 * 1024); } bool getInCriticalSection() const { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); return _inCriticalSection; } void setInCriticalSection(bool b) { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); _inCriticalSection = b; _inCriticalSectionCV.notify_all(); } std::string getNS() const { - std::lock_guard<std::mutex> sl(_mutex); + stdx::lock_guard<stdx::mutex> sl(_mutex); return _ns; } @@ -694,9 +694,9 @@ public: */ bool waitTillNotInCriticalSection(int maxSecondsToWait) { const auto deadline = system_clock::now() + seconds(maxSecondsToWait); - std::unique_lock<std::mutex> lk(_mutex); + stdx::unique_lock<stdx::mutex> lk(_mutex); while (_inCriticalSection) { - if (std::cv_status::timeout == _inCriticalSectionCV.wait_until(lk, deadline)) + if (stdx::cv_status::timeout == _inCriticalSectionCV.wait_until(lk, deadline)) return false; } @@ -709,11 +709,11 @@ public: private: bool _getActive() const { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); return _active; } void _setActive(bool b) { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); _active = b; } @@ -735,7 +735,7 @@ private: virtual void commit() { switch (_op) { case 'd': { - std::lock_guard<std::mutex> sl(_migrateFromStatus->_mutex); + stdx::lock_guard<stdx::mutex> sl(_migrateFromStatus->_mutex); _migrateFromStatus->_deleted.push_back(_idObj); _migrateFromStatus->_memoryUsed += _idObj.firstElement().size() + 5; break; @@ -743,7 +743,7 @@ private: case 'i': case 'u': { - std::lock_guard<std::mutex> sl(_migrateFromStatus->_mutex); + stdx::lock_guard<stdx::mutex> sl(_migrateFromStatus->_mutex); _migrateFromStatus->_reload.push_back(_idObj); _migrateFromStatus->_memoryUsed += _idObj.firstElement().size() + 5; break; @@ -819,9 +819,9 @@ private: // // Global Lock -> _mutex -> _cloneLocsMutex - mutable std::mutex _mutex; + mutable stdx::mutex _mutex; - std::condition_variable _inCriticalSectionCV; // (M) + stdx::condition_variable _inCriticalSectionCV; // (M) // Is migration currently in critical section. This can be used to block new writes. bool _inCriticalSection; // (M) @@ -845,7 +845,7 @@ private: BSONObj _max; // (MG) BSONObj _shardKeyPattern; // (MG) - mutable std::mutex _cloneLocsMutex; + mutable stdx::mutex _cloneLocsMutex; // List of record id that needs to be transferred from here to the other side. set<RecordId> _cloneLocs; // (C) @@ -1804,12 +1804,12 @@ public: _state(READY) {} void setState(State newState) { - std::lock_guard<std::mutex> sl(_mutex); + stdx::lock_guard<stdx::mutex> sl(_mutex); _state = newState; } State getState() const { - std::lock_guard<std::mutex> sl(_mutex); + stdx::lock_guard<stdx::mutex> sl(_mutex); return _state; } @@ -1821,7 +1821,7 @@ public: const BSONObj& min, const BSONObj& max, const BSONObj& shardKeyPattern) { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); if (_active) { return Status(ErrorCodes::ConflictingOperationInProgress, @@ -1861,7 +1861,7 @@ public: _go(txn, ns, min, max, shardKeyPattern, fromShard, epoch, writeConcern); } catch (std::exception& e) { { - std::lock_guard<std::mutex> sl(_mutex); + stdx::lock_guard<stdx::mutex> sl(_mutex); _state = FAIL; _errmsg = e.what(); } @@ -1869,7 +1869,7 @@ public: error() << "migrate failed: " << e.what() << migrateLog; } catch (...) { { - std::lock_guard<std::mutex> sl(_mutex); + stdx::lock_guard<stdx::mutex> sl(_mutex); _state = FAIL; _errmsg = "UNKNOWN ERROR"; } @@ -2146,7 +2146,7 @@ public: thisTime++; { - std::lock_guard<std::mutex> statsLock(_mutex); + stdx::lock_guard<stdx::mutex> statsLock(_mutex); _numCloned++; _clonedBytes += docToClone.objsize(); } @@ -2320,7 +2320,7 @@ public: } void status(BSONObjBuilder& b) { - std::lock_guard<std::mutex> sl(_mutex); + stdx::lock_guard<stdx::mutex> sl(_mutex); b.appendBool("active", _active); @@ -2536,7 +2536,7 @@ public: } bool startCommit() { - std::unique_lock<std::mutex> lock(_mutex); + stdx::unique_lock<stdx::mutex> lock(_mutex); if (_state != STEADY) { return false; @@ -2545,7 +2545,7 @@ public: const auto deadline = system_clock::now() + seconds(30); _state = COMMIT_START; while (_active) { - if (std::cv_status::timeout == isActiveCV.wait_until(lock, deadline)) { + if (stdx::cv_status::timeout == isActiveCV.wait_until(lock, deadline)) { _state = FAIL; log() << "startCommit never finished!" << migrateLog; return false; @@ -2561,25 +2561,25 @@ public: } void abort() { - std::lock_guard<std::mutex> sl(_mutex); + stdx::lock_guard<stdx::mutex> sl(_mutex); _state = ABORT; _errmsg = "aborted"; } bool getActive() const { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); return _active; } void setActive(bool b) { - std::lock_guard<std::mutex> lk(_mutex); + stdx::lock_guard<stdx::mutex> lk(_mutex); _active = b; isActiveCV.notify_all(); } // Guards all fields. - mutable std::mutex _mutex; + mutable stdx::mutex _mutex; bool _active; - std::condition_variable isActiveCV; + stdx::condition_variable isActiveCV; std::string _ns; std::string _from; @@ -2778,14 +2778,14 @@ public: return appendCommandStatus(result, prepareStatus); } - std::thread m(migrateThread, - ns, - min, - max, - shardKeyPattern, - fromShard, - currentVersion.epoch(), - writeConcern); + stdx::thread m(migrateThread, + ns, + min, + max, + shardKeyPattern, + fromShard, + currentVersion.epoch(), + writeConcern); m.detach(); result.appendBool("started", true); diff --git a/src/mongo/s/mongos_options_init.cpp b/src/mongo/s/mongos_options_init.cpp index 335ddef25d8..85528114de4 100644 --- a/src/mongo/s/mongos_options_init.cpp +++ b/src/mongo/s/mongos_options_init.cpp @@ -28,6 +28,8 @@ #include "mongo/s/mongos_options.h" +#include <iostream> + #include "mongo/util/options_parser/startup_option_init.h" #include "mongo/util/options_parser/startup_options.h" #include "mongo/util/quick_exit.h" diff --git a/src/mongo/shell/bench.cpp b/src/mongo/shell/bench.cpp index bd446e49018..5a02ef00317 100644 --- a/src/mongo/shell/bench.cpp +++ b/src/mongo/shell/bench.cpp @@ -345,7 +345,7 @@ BenchRunWorker::BenchRunWorker(size_t id, BenchRunWorker::~BenchRunWorker() {} void BenchRunWorker::start() { - stdx::thread(stdx::bind(&BenchRunWorker::run, this)); + stdx::thread(stdx::bind(&BenchRunWorker::run, this)).detach(); } bool BenchRunWorker::shouldStop() const { diff --git a/src/mongo/shell/shell_utils_launcher.cpp b/src/mongo/shell/shell_utils_launcher.cpp index 56356ba4c6c..e4eb10124af 100644 --- a/src/mongo/shell/shell_utils_launcher.cpp +++ b/src/mongo/shell/shell_utils_launcher.cpp @@ -558,6 +558,7 @@ BSONObj StartMongoProgram(const BSONObj& a, void* data) { ProgramRunner r(a); r.start(); stdx::thread t(r); + t.detach(); return BSON(string("") << r.pid().asLongLong()); } @@ -565,6 +566,7 @@ BSONObj RunMongoProgram(const BSONObj& a, void* data) { ProgramRunner r(a); r.start(); stdx::thread t(r); + t.detach(); int exit_code = -123456; // sentinel value wait_for_pid(r.pid(), true, &exit_code); if (r.port() > 0) { @@ -579,6 +581,7 @@ BSONObj RunProgram(const BSONObj& a, void* data) { ProgramRunner r(a); r.start(); stdx::thread t(r); + t.detach(); int exit_code = -123456; // sentinel value wait_for_pid(r.pid(), true, &exit_code); registry.deletePid(r.pid()); diff --git a/src/mongo/shell/shell_utils_launcher.h b/src/mongo/shell/shell_utils_launcher.h index 49ec94f91d9..9fdb07cf3f7 100644 --- a/src/mongo/shell/shell_utils_launcher.h +++ b/src/mongo/shell/shell_utils_launcher.h @@ -38,6 +38,7 @@ #include "mongo/bson/bsonobj.h" #include "mongo/platform/process_id.h" +#include "mongo/stdx/mutex.h" namespace mongo { @@ -95,7 +96,7 @@ public: private: std::map<int, std::pair<ProcessId, int>> _ports; std::map<ProcessId, int> _pids; - mutable boost::recursive_mutex _mutex; + mutable stdx::recursive_mutex _mutex; #ifdef _WIN32 public: diff --git a/src/mongo/stdx/future.h b/src/mongo/stdx/future.h new file mode 100644 index 00000000000..bbc46efac14 --- /dev/null +++ b/src/mongo/stdx/future.h @@ -0,0 +1,44 @@ +/** + * Copyright (C) 2015 MongoDB Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License, version 3, + * as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + * As a special exception, the copyright holders give permission to link the + * code of portions of this program with the OpenSSL library under certain + * conditions as described in each individual source file and distribute + * linked combinations including the program with the OpenSSL library. You + * must comply with the GNU Affero General Public License in all respects for + * all of the code used other than as permitted herein. If you modify file(s) + * with this exception, you may extend this exception to your version of the + * file(s), but you are not obligated to do so. If you do not wish to do so, + * delete this exception statement from your version. If you delete this + * exception statement from all source files in the program, then also delete + * it in the license file. + */ + +#pragma once + +#include <boost/thread/future.hpp> + +namespace mongo { +namespace stdx { + +using boost::async; +using boost::future; +using boost::future_status; +using boost::launch; +using boost::packaged_task; +using boost::promise; + +} // namespace stdx +} // namespace mongo diff --git a/src/mongo/stdx/mutex.h b/src/mongo/stdx/mutex.h index bdb5f2f6486..9dc0f0c07b1 100644 --- a/src/mongo/stdx/mutex.h +++ b/src/mongo/stdx/mutex.h @@ -28,7 +28,7 @@ #pragma once -#include <boost/thread/lock_guard.hpp> +#include <boost/thread/locks.hpp> #include <boost/thread/mutex.hpp> #include <boost/thread/recursive_mutex.hpp> diff --git a/src/mongo/tools/bridge.cpp b/src/mongo/tools/bridge.cpp index b22153a3db9..e24df98dc67 100644 --- a/src/mongo/tools/bridge.cpp +++ b/src/mongo/tools/bridge.cpp @@ -142,6 +142,7 @@ public: ports.insert(mp); Forwarder f(*mp); stdx::thread t(f); + t.detach(); } }; diff --git a/src/mongo/util/background.cpp b/src/mongo/util/background.cpp index a98d92a0a41..f316f31e683 100644 --- a/src/mongo/util/background.cpp +++ b/src/mongo/util/background.cpp @@ -33,13 +33,11 @@ #include "mongo/util/background.h" -#include <chrono> -#include <condition_variable> -#include <functional> -#include <mutex> -#include <thread> - #include "mongo/config.h" +#include "mongo/stdx/condition_variable.h" +#include "mongo/stdx/functional.h" +#include "mongo/stdx/mutex.h" +#include "mongo/stdx/thread.h" #include "mongo/util/concurrency/mutex.h" #include "mongo/util/concurrency/spin_lock.h" #include "mongo/util/concurrency/thread_name.h" @@ -82,11 +80,11 @@ private: void _runTask(PeriodicTask* task); // _mutex protects the _shutdownRequested flag and the _tasks vector. - std::mutex _mutex; + stdx::mutex _mutex; // The condition variable is used to sleep for the interval between task // executions, and is notified when the _shutdownRequested flag is toggled. - std::condition_variable _cond; + stdx::condition_variable _cond; // Used to break the loop. You should notify _cond after changing this to true // so that shutdown proceeds promptly. @@ -133,8 +131,8 @@ bool runnerDestroyed; struct BackgroundJob::JobStatus { JobStatus() : state(NotStarted) {} - std::mutex mutex; - std::condition_variable done; + stdx::mutex mutex; + stdx::condition_variable done; State state; }; @@ -172,7 +170,7 @@ void BackgroundJob::jobBody() { { // 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. - std::unique_lock<std::mutex> l(_status->mutex); + stdx::unique_lock<stdx::mutex> l(_status->mutex); _status->state = Done; _status->done.notify_all(); } @@ -182,7 +180,7 @@ void BackgroundJob::jobBody() { } void BackgroundJob::go() { - std::unique_lock<std::mutex> l(_status->mutex); + stdx::unique_lock<stdx::mutex> l(_status->mutex); massert(17234, mongoutils::str::stream() << "backgroundJob already running: " << name(), _status->state != Running); @@ -190,14 +188,14 @@ void BackgroundJob::go() { // If the job is already 'done', for instance because it was cancelled or already // finished, ignore additional requests to run the job. if (_status->state == NotStarted) { - std::thread t(std::bind(&BackgroundJob::jobBody, this)); + stdx::thread t(stdx::bind(&BackgroundJob::jobBody, this)); t.detach(); _status->state = Running; } } Status BackgroundJob::cancel() { - std::unique_lock<std::mutex> l(_status->mutex); + stdx::unique_lock<stdx::mutex> l(_status->mutex); if (_status->state == Running) return Status(ErrorCodes::IllegalOperation, "Cannot cancel a running BackgroundJob"); @@ -212,11 +210,11 @@ Status BackgroundJob::cancel() { bool BackgroundJob::wait(unsigned msTimeOut) { verify(!_selfDelete); // you cannot call wait on a self-deleting job - const auto deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(msTimeOut); - std::unique_lock<std::mutex> l(_status->mutex); + const auto deadline = stdx::chrono::system_clock::now() + stdx::chrono::milliseconds(msTimeOut); + stdx::unique_lock<stdx::mutex> l(_status->mutex); while (_status->state != Done) { if (msTimeOut) { - if (std::cv_status::timeout == _status->done.wait_until(l, deadline)) + if (stdx::cv_status::timeout == _status->done.wait_until(l, deadline)) return false; } else { _status->done.wait(l); @@ -226,12 +224,12 @@ bool BackgroundJob::wait(unsigned msTimeOut) { } BackgroundJob::State BackgroundJob::getState() const { - std::unique_lock<std::mutex> l(_status->mutex); + stdx::unique_lock<stdx::mutex> l(_status->mutex); return _status->state; } bool BackgroundJob::running() const { - std::unique_lock<std::mutex> l(_status->mutex); + stdx::unique_lock<stdx::mutex> l(_status->mutex); return _status->state == Running; } @@ -286,12 +284,12 @@ Status PeriodicTask::stopRunningPeriodicTasks(int gracePeriodMillis) { } void PeriodicTaskRunner::add(PeriodicTask* task) { - std::lock_guard<std::mutex> lock(_mutex); + stdx::lock_guard<stdx::mutex> lock(_mutex); _tasks.push_back(task); } void PeriodicTaskRunner::remove(PeriodicTask* task) { - std::lock_guard<std::mutex> lock(_mutex); + stdx::lock_guard<stdx::mutex> lock(_mutex); for (size_t i = 0; i != _tasks.size(); i++) { if (_tasks[i] == task) { _tasks[i] = NULL; @@ -302,7 +300,7 @@ void PeriodicTaskRunner::remove(PeriodicTask* task) { Status PeriodicTaskRunner::stop(int gracePeriodMillis) { { - std::lock_guard<std::mutex> lock(_mutex); + stdx::lock_guard<stdx::mutex> lock(_mutex); _shutdownRequested = true; _cond.notify_one(); } @@ -316,11 +314,11 @@ Status PeriodicTaskRunner::stop(int gracePeriodMillis) { void PeriodicTaskRunner::run() { // Use a shorter cycle time in debug mode to help catch race conditions. - const std::chrono::seconds waitTime(kDebugBuild ? 5 : 60); + const stdx::chrono::seconds waitTime(kDebugBuild ? 5 : 60); - std::unique_lock<std::mutex> lock(_mutex); + stdx::unique_lock<stdx::mutex> lock(_mutex); while (!_shutdownRequested) { - if (std::cv_status::timeout == _cond.wait_for(lock, waitTime)) + if (stdx::cv_status::timeout == _cond.wait_for(lock, waitTime)) _runTasks(); } } diff --git a/src/mongo/util/concurrency/rwlockimpl.h b/src/mongo/util/concurrency/rwlockimpl.h index 898197a9777..d0d4c8fad99 100644 --- a/src/mongo/util/concurrency/rwlockimpl.h +++ b/src/mongo/util/concurrency/rwlockimpl.h @@ -30,7 +30,8 @@ #pragma once -#include "mutex.h" +#include "mongo/stdx/chrono.h" +#include "mongo/util/concurrency/mutex.h" #if defined(NTDDI_VERSION) && defined(NTDDI_WIN7) && (NTDDI_VERSION >= NTDDI_WIN7) @@ -115,20 +116,25 @@ public: #if defined(_WIN32) #include "shared_mutex_win.hpp" namespace mongo { -typedef boost::modified_shared_mutex shared_mutex; -} +namespace detail { +using rwlock_underlying_shared_mutex = boost::modified_shared_mutex; +} // namespace detail +} // namespace mongo #else +#include <boost/chrono.hpp> #include <boost/thread/shared_mutex.hpp> namespace mongo { -using boost::shared_mutex; -} +namespace detail { +using rwlock_underlying_shared_mutex = boost::shared_mutex; +} // namespace detail +} // namespace mongo #endif namespace mongo { class RWLockBase { MONGO_DISALLOW_COPYING(RWLockBase); friend class SimpleRWLock; - shared_mutex _m; + detail::rwlock_underlying_shared_mutex _m; protected: RWLockBase() = default; @@ -155,10 +161,18 @@ protected: _m.unlock_shared(); } bool lock_shared_try(int millis) { +#if defined(_WIN32) return _m.timed_lock_shared(boost::posix_time::milliseconds(millis)); +#else + return _m.try_lock_shared_for(boost::chrono::milliseconds(millis)); +#endif } bool lock_try(int millis = 0) { +#if defined(_WIN32) return _m.timed_lock(boost::posix_time::milliseconds(millis)); +#else + return _m.try_lock_for(boost::chrono::milliseconds(millis)); +#endif } public: diff --git a/src/mongo/util/concurrency/ticketholder.cpp b/src/mongo/util/concurrency/ticketholder.cpp index 17efed9300d..34535fa98b6 100644 --- a/src/mongo/util/concurrency/ticketholder.cpp +++ b/src/mongo/util/concurrency/ticketholder.cpp @@ -30,6 +30,9 @@ #include "mongo/platform/basic.h" #include "mongo/util/concurrency/ticketholder.h" + +#include <iostream> + #include "mongo/util/log.h" #include "mongo/util/mongoutils/str.h" diff --git a/src/mongo/util/net/message_server_port.cpp b/src/mongo/util/net/message_server_port.cpp index 0a56c9203c1..ac9a8aac083 100644 --- a/src/mongo/util/net/message_server_port.cpp +++ b/src/mongo/util/net/message_server_port.cpp @@ -32,6 +32,7 @@ #include "mongo/platform/basic.h" #include <memory> +#include <system_error> #include "mongo/base/disallow_copying.h" #include "mongo/config.h" @@ -116,7 +117,10 @@ public: try { #ifndef __linux__ // TODO: consider making this ifdef _WIN32 - { stdx::thread thr(stdx::bind(&handleIncomingMsg, portWithHandler.get())); } + { + stdx::thread thr(stdx::bind(&handleIncomingMsg, portWithHandler.get())); + thr.detach(); + } #else pthread_attr_t attrs; pthread_attr_init(&attrs); @@ -147,18 +151,16 @@ public: if (failed) { log() << "pthread_create failed: " << errnoWithDescription(failed) << endl; - throw boost::thread_resource_error(); // for consistency with boost::thread + throw std::system_error( + std::make_error_code(std::errc::resource_unavailable_try_again)); } #endif // __linux__ portWithHandler.release(); sleepAfterClosingPort.Dismiss(); - } catch (boost::thread_resource_error&) { - Listener::globalTicketHolder.release(); - log() << "can't create new thread, closing connection" << endl; } catch (...) { Listener::globalTicketHolder.release(); - log() << "unknown error accepting new socket" << endl; + log() << "failed to create thread after accepting new connection, closing connection"; } } diff --git a/src/mongo/util/net/sock_test.cpp b/src/mongo/util/net/sock_test.cpp index 26f0c2c821a..e294bb1b738 100644 --- a/src/mongo/util/net/sock_test.cpp +++ b/src/mongo/util/net/sock_test.cpp @@ -154,6 +154,7 @@ SocketPair socketPair(const int type, const int protocol) { stdx::bind(&detail::awaitConnect, &connectSock, *connectRes, boost::ref(connected))); connected.waitToBeNotified(); + connector.join(); if (connectSock == INVALID_SOCKET) { closesocket(listenSock); ::freeaddrinfo(res); @@ -164,6 +165,7 @@ SocketPair socketPair(const int type, const int protocol) { } accepted.waitToBeNotified(); + acceptor.join(); if (acceptSock == INVALID_SOCKET) { closesocket(listenSock); ::freeaddrinfo(res); diff --git a/src/mongo/util/ntservice.cpp b/src/mongo/util/ntservice.cpp index e4c0eb70348..b70835d1ab6 100644 --- a/src/mongo/util/ntservice.cpp +++ b/src/mongo/util/ntservice.cpp @@ -39,6 +39,9 @@ #include "mongo/db/client.h" #include "mongo/db/instance.h" +#include "mongo/stdx/chrono.h" +#include "mongo/stdx/future.h" +#include "mongo/stdx/thread.h" #include "mongo/util/assert_util.h" #include "mongo/util/exit.h" #include "mongo/util/log.h" @@ -502,15 +505,6 @@ bool reportStatus(DWORD reportState, DWORD waitHint, DWORD exitCode) { return SetServiceStatus(_statusHandle, &ssStatus); } -static void serviceStopWorker() { - Client::initThread("serviceStopWorker"); - - // Stop the process - // TODO: SERVER-5703, separate the "cleanup for shutdown" functionality from - // the "terminate process" functionality in exitCleanly. - exitCleanly(EXIT_WINDOWS_SERVICE_STOP); -} - // Minimum of time we tell Windows to wait before we are guilty of a hung shutdown const int kStopWaitHintMillis = 30000; @@ -519,12 +513,23 @@ const int kStopWaitHintMillis = 30000; // On client OSes, SERVICE_CONTROL_SHUTDOWN has a 5 second timeout configured in // HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control static void serviceStop() { - stdx::thread serviceWorkerThread(serviceStopWorker); + stdx::packaged_task<void()> exitCleanlyTask([] { + Client::initThread("serviceStopWorker"); + // Stop the process + // TODO: SERVER-5703, separate the "cleanup for shutdown" functionality from + // the "terminate process" functionality in exitCleanly. + exitCleanly(EXIT_WINDOWS_SERVICE_STOP); + }); + stdx::future<void> exitedCleanly = exitCleanlyTask.get_future(); + + // Launch the packaged task in a thread. We needn't ever join it, + // so it doesn't even need a name. + stdx::thread(std::move(exitCleanlyTask)).detach(); + + const auto timeout = stdx::chrono::milliseconds(kStopWaitHintMillis / 2); // We periodically check if we are done exiting by polling at half of each wait interval - // - while ( - !serviceWorkerThread.try_join_for(boost::chrono::milliseconds(kStopWaitHintMillis / 2))) { + while (exitedCleanly.wait_for(timeout) != stdx::future_status::ready) { reportStatus(SERVICE_STOP_PENDING, kStopWaitHintMillis); log() << "Service Stop is waiting for storage engine to finish shutdown"; } diff --git a/src/mongo/util/queue.h b/src/mongo/util/queue.h index b2475fbebfd..f204abb2484 100644 --- a/src/mongo/util/queue.h +++ b/src/mongo/util/queue.h @@ -29,12 +29,11 @@ #pragma once -#include <chrono> -#include <condition_variable> -#include <mutex> #include <limits> #include <queue> +#include "mongo/stdx/chrono.h" +#include "mongo/stdx/condition_variable.h" #include "mongo/base/disallow_copying.h" namespace mongo { @@ -66,7 +65,7 @@ public: BlockingQueue(size_t size, getSizeFunc f) : _maxSize(size), _currentSize(0), _getSize(f) {} void push(T const& t) { - std::unique_lock<std::mutex> l(_lock); + stdx::unique_lock<stdx::mutex> l(_lock); size_t tSize = _getSize(t); while (_currentSize + tSize > _maxSize) { _cvNoLongerFull.wait(l); @@ -77,7 +76,7 @@ public: } bool empty() const { - std::lock_guard<std::mutex> l(_lock); + stdx::lock_guard<stdx::mutex> l(_lock); return _queue.empty(); } @@ -85,7 +84,7 @@ public: * The size as measured by the size function. Default to counting each item */ size_t size() const { - std::lock_guard<std::mutex> l(_lock); + stdx::lock_guard<stdx::mutex> l(_lock); return _currentSize; } @@ -100,19 +99,19 @@ public: * The number/count of items in the queue ( _queue.size() ) */ size_t count() const { - std::lock_guard<std::mutex> l(_lock); + stdx::lock_guard<stdx::mutex> l(_lock); return _queue.size(); } void clear() { - std::lock_guard<std::mutex> l(_lock); + stdx::lock_guard<stdx::mutex> l(_lock); _queue = std::queue<T>(); _currentSize = 0; _cvNoLongerFull.notify_one(); } bool tryPop(T& t) { - std::lock_guard<std::mutex> l(_lock); + stdx::lock_guard<stdx::mutex> l(_lock); if (_queue.empty()) return false; @@ -125,7 +124,7 @@ public: } T blockingPop() { - std::unique_lock<std::mutex> l(_lock); + stdx::unique_lock<stdx::mutex> l(_lock); while (_queue.empty()) _cvNoLongerEmpty.wait(l); @@ -144,11 +143,11 @@ public: * otherwise return false and t won't be changed */ bool blockingPop(T& t, int maxSecondsToWait) { - using namespace std::chrono; + using namespace stdx::chrono; const auto deadline = system_clock::now() + seconds(maxSecondsToWait); - std::unique_lock<std::mutex> l(_lock); + stdx::unique_lock<stdx::mutex> l(_lock); while (_queue.empty()) { - if (std::cv_status::timeout == _cvNoLongerEmpty.wait_until(l, deadline)) + if (stdx::cv_status::timeout == _cvNoLongerEmpty.wait_until(l, deadline)) return false; } @@ -162,11 +161,11 @@ public: // Obviously, this should only be used when you have // only one consumer bool blockingPeek(T& t, int maxSecondsToWait) { - using namespace std::chrono; + using namespace stdx::chrono; const auto deadline = system_clock::now() + seconds(maxSecondsToWait); - std::unique_lock<std::mutex> l(_lock); + stdx::unique_lock<stdx::mutex> l(_lock); while (_queue.empty()) { - if (std::cv_status::timeout == _cvNoLongerEmpty.wait_until(l, deadline)) + if (stdx::cv_status::timeout == _cvNoLongerEmpty.wait_until(l, deadline)) return false; } @@ -177,7 +176,7 @@ public: // Obviously, this should only be used when you have // only one consumer bool peek(T& t) { - std::unique_lock<std::mutex> l(_lock); + stdx::unique_lock<stdx::mutex> l(_lock); if (_queue.empty()) { return false; } @@ -187,13 +186,13 @@ public: } private: - mutable std::mutex _lock; + mutable stdx::mutex _lock; std::queue<T> _queue; const size_t _maxSize; size_t _currentSize; getSizeFunc _getSize; - std::condition_variable _cvNoLongerFull; - std::condition_variable _cvNoLongerEmpty; + stdx::condition_variable _cvNoLongerFull; + stdx::condition_variable _cvNoLongerEmpty; }; } diff --git a/src/mongo/util/tick_source_mock.cpp b/src/mongo/util/tick_source_mock.cpp index 15930a1b18a..a64c4f146b3 100644 --- a/src/mongo/util/tick_source_mock.cpp +++ b/src/mongo/util/tick_source_mock.cpp @@ -28,6 +28,8 @@ #include "mongo/util/tick_source_mock.h" +#include <utility> + namespace mongo { namespace { diff --git a/src/mongo/util/time_support.h b/src/mongo/util/time_support.h index 2ec19ed12eb..8991ba85ec1 100644 --- a/src/mongo/util/time_support.h +++ b/src/mongo/util/time_support.h @@ -54,7 +54,10 @@ void time_t_to_Struct(time_t t, struct tm* buf, bool local = false); std::string time_t_to_String_short(time_t t); // -// Operators for putting durations to streams. +// Operators for putting durations to streams. Note that these will +// *not* normally be found by ADL since the duration types are +// typedefs, but see the handling of chrono::duration in +// logstream_builder.h for why they are useful. // std::ostream& operator<<(std::ostream& os, Microseconds us); diff --git a/src/mongo/util/time_support_test.cpp b/src/mongo/util/time_support_test.cpp index dfdd01863cb..64a6b3b16bf 100644 --- a/src/mongo/util/time_support_test.cpp +++ b/src/mongo/util/time_support_test.cpp @@ -824,8 +824,9 @@ TEST(SystemTime, ConvertDateToSystemTime) { const std::string isoTimeString = "2015-05-14T17:28:33.123Z"; const Date_t aDate = unittest::assertGet(dateFromISOString(isoTimeString)); const auto aTimePoint = aDate.toSystemTimePoint(); - ASSERT_EQUALS(aDate.toDurationSinceEpoch(), - aTimePoint - stdx::chrono::system_clock::from_time_t(0)); + const auto actual = aTimePoint - stdx::chrono::system_clock::from_time_t(0); + ASSERT(aDate.toDurationSinceEpoch() == actual) << "Expected " << aDate << "; but found " + << Date_t::fromDurationSinceEpoch(actual); ASSERT_EQUALS(aDate, Date_t(aTimePoint)); } |