Switch from boost::thread to std::thread

Author: ongardie

GNUmakefile

@@ -60,7 +60,7 @@ endif
 # -Winline
 
 LIBS := $(EXTRALIBS) -lpcrecpp -lboost_program_options -lprotobuf -lrt \
-        -lpthread -lboost_thread -lssl -lcrypto
+        -lpthread -lssl -lcrypto
 ifeq ($(DEBUG),yes)
 # -rdynamic generates more useful backtraces when you have debugging symbols
 LIBS += -rdynamic

src/BackupService.cc

@@ -13,7 +13,7 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <boost/thread.hpp>
+#include <thread>
 
 #include "BackupService.h"
 #include "BackupStorage.h"
@@ -150,7 +150,7 @@ Status
 BackupService::SegmentInfo::appendRecoverySegment(uint64_t partitionId,
                                                   Buffer& buffer)
 {
-    Lock lock(mutex, boost::try_to_lock_t());
+    Lock lock(mutex, std::try_to_lock_t());
     if (!lock.owns_lock()) {
         LOG(DEBUG, "Deferring because couldn't acquire lock immediately");
         return STATUS_RETRY;
@@ -649,7 +649,7 @@ BackupService::IoScheduler::store(SegmentInfo& info)
  *      returns.
  */
 void
-BackupService::IoScheduler::shutdown(boost::thread& ioThread)
+BackupService::IoScheduler::shutdown(std::thread& ioThread)
 {
     {
         Lock lock(queueMutex);
@@ -875,7 +875,7 @@ BackupService::BackupService(const Config& config,
 #ifdef SINGLE_THREADED_BACKUP
     , ioThread()
 #else
-    , ioThread(boost::ref(ioScheduler))
+    , ioThread(std::ref(ioScheduler))
 #endif
     , initCalled(false)
 {
@@ -1299,7 +1299,8 @@ BackupService::startReadingData(
                                    partitions,
                                    recoveryThreadCount);
     ++recoveryThreadCount;
-    boost::thread builderThread(builder);
+    std::thread builderThread(builder);
+    builderThread.detach();
     LOG(DEBUG, "Kicked off building recovery segments; "
                "main thread going back to dispatching requests");
 #endif

src/BackupService.h

@@ -28,7 +28,7 @@
 #else
 #include <cstdatomic>
 #endif
-#include <boost/thread.hpp>
+#include <thread>
 #include <boost/scoped_ptr.hpp>
 #include <boost/pool/pool.hpp>
 #include <map>
@@ -108,7 +108,7 @@ class BackupService : public Service {
         typedef boost::pool<SegmentAllocator> Pool;
 
         /// The type of lock used to make access to #pool thread safe.
-        typedef boost::unique_lock<boost::mutex> Lock;
+        typedef std::unique_lock<std::mutex> Lock;
 
         explicit ThreadSafePool(uint32_t chunkSize)
             : allocatedChunks()
@@ -162,7 +162,7 @@ class BackupService : public Service {
         uint32_t allocatedChunks;
 
         /// Used to serialize access to #pool and #allocatedChunks.
-        boost::mutex mutex;
+        std::mutex mutex;
 
         /// The backing pool that manages memory chunks.
         Pool pool;
@@ -179,7 +179,7 @@ class BackupService : public Service {
     class SegmentInfo {
       public:
         /// The type of locks used to lock #mutex.
-        typedef boost::unique_lock<boost::mutex> Lock;
+        typedef std::unique_lock<std::mutex> Lock;
 
         /**
          * Tracks current state of the segment which is sufficient to
@@ -319,14 +319,14 @@ class BackupService : public Service {
          * Provides mutal exclusion between all public method calls and
          * storage operations that can be performed on SegmentInfos.
          */
-        boost::mutex mutex;
+        std::mutex mutex;
 
         /**
          * Notified when a store or load for this segment completes, or
          * when this segment's recovery segments are constructed and valid.
          * Used in conjunction with #mutex.
          */
-        boost::condition_variable condition;
+        std::condition_variable condition;
 
         /// Gatekeeper through which async IOs are scheduled.
         IoScheduler& ioScheduler;
@@ -404,19 +404,19 @@ class BackupService : public Service {
         void load(SegmentInfo& info);
         void quiesce();
         void store(SegmentInfo& info);
-        void shutdown(boost::thread& ioThread);
+        void shutdown(std::thread& ioThread);
 
       private:
         void doLoad(SegmentInfo& info) const;
         void doStore(SegmentInfo& info) const;
 
-        typedef boost::unique_lock<boost::mutex> Lock;
+        typedef std::unique_lock<std::mutex> Lock;
 
         /// Protects #loadQueue, #storeQueue, and #running.
-        boost::mutex queueMutex;
+        std::mutex queueMutex;
 
         /// Notified when new requests are added to either queue.
-        boost::condition_variable queueCond;
+        std::condition_variable queueCond;
 
         /// Queue of SegmentInfos to be loaded from storage.
         std::queue<SegmentInfo*> loadQueue;
@@ -582,7 +582,7 @@ class BackupService : public Service {
     /// Gatekeeper through which async IOs are scheduled.
     IoScheduler ioScheduler;
     /// The thread driving #ioScheduler.
-    boost::thread ioThread;
+    std::thread ioThread;
 
     /// Used to ensure that init() is invoked before the dispatcher runs.
     bool initCalled;

src/BackupServiceTest.cc

@@ -759,7 +759,7 @@ class SegmentInfoTest : public ::testing::Test {
         , pool{segmentSize}
         , storage{segmentSize, 2}
         , ioScheduler()
-        , ioThread(boost::ref(ioScheduler))
+        , ioThread(std::ref(ioScheduler))
         , info{storage, pool, ioScheduler,
             ServerId(99, 0), 88, segmentSize, true}
     {
@@ -774,7 +774,7 @@ class SegmentInfoTest : public ::testing::Test {
     BackupService::ThreadSafePool pool;
     InMemoryStorage storage;
     BackupService::IoScheduler ioScheduler;
-    boost::thread ioThread;
+    std::thread ioThread;
     SegmentInfo info;
 };
 

src/BackupStorageBenchmark.cc

@@ -13,7 +13,7 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <boost/thread/thread.hpp>
+#include <thread>
 
 #include "BackupStorage.h"
 #include "Cycles.h"
@@ -125,7 +125,7 @@ struct Bench {
         int i = 0;
         foreach (auto* handle, allocated) {
             if (!(i++ % 3))
-                boost::thread(Store(storage, scratch, *(writeHandle++)));
+                std::thread(Store(storage, scratch, *(writeHandle++)));
             uint64_t start = Cycles::rdtsc();
             storage.getSegment(handle, scratch);
             uint64_t getTime = Cycles::rdtsc() - start;

src/Dispatch.h

@@ -21,8 +21,7 @@
 #else
 #include <cstdatomic>
 #endif
-#include <boost/thread.hpp>
-#include <boost/thread/locks.hpp>
+#include <thread>
 
 #include "Common.h"
 #include "AtomicInt.h"
@@ -229,7 +228,7 @@ class Dispatch {
         /// is constructed in a thread other than the dispatch thread
         /// (no mutual exclusion is needed if the Lock is created in
         /// the dispatch thread).
-        Tub<boost::lock_guard<SpinLock>> lock;
+        Tub<std::lock_guard<SpinLock>> lock;
         DISALLOW_COPY_AND_ASSIGN(Lock);
     };
 
@@ -253,7 +252,7 @@ class Dispatch {
     // We start a separate thread to invoke epoll kernel calls, so the
     // main polling loop is not delayed by kernel calls.  This thread
     // is only used when there are active Files.
-    Tub<boost::thread> epollThread;
+    Tub<std::thread> epollThread;
 
     // Read and write descriptors for a pipe.  The epoll thread always has
     // the read fd for this pipe in its active set; writing data to the pipe

src/DispatchTest.cc

@@ -315,7 +315,7 @@ TEST_F(DispatchTest, poll_locking) {
     // from there.
     CountPoller* counter = NULL;
     volatile int flag = 0;
-    boost::thread thread(lockTestThread, &Context::get(), &flag, &counter);
+    std::thread thread(lockTestThread, &Context::get(), &flag, &counter);
     Dispatch& dispatch = *Context::get().dispatch;
 
     // Wait for the child thread to start up and enter its polling loop.
@@ -480,7 +480,7 @@ TEST_F(DispatchTest, isDispatchThread) {
     td->hasDedicatedThread = true;
     EXPECT_TRUE(td->isDispatchThread());
     bool childResult = true;
-    boost::thread(checkDispatchThread, td, &childResult).join();
+    std::thread(checkDispatchThread, td, &childResult).join();
     EXPECT_FALSE(childResult);
 }
 
@@ -734,7 +734,7 @@ TEST_F(DispatchTest, epollThreadMain_signalEventsAndExit) {
 
     // Start up the polling thread; it will signal the first ready file.
     td->readyFd = -1;
-    boost::thread(epollThreadWrapper, &Context::get()).detach();
+    std::thread(epollThreadWrapper, &Context::get()).detach();
     waitForReadyFd(1.0);
     EXPECT_EQ(43, td->readyFd);
     EXPECT_EQ(Dispatch::FileEvent::WRITABLE, td->readyEvents);

src/FailureDetector.cc

@@ -18,6 +18,7 @@
 
 #include "Common.h"
 #include "Cycles.h"
+#include "Fence.h"
 #include "PingClient.h"
 #include "CoordinatorClient.h"
 #include "FailureDetector.h"
@@ -51,6 +52,7 @@ FailureDetector::FailureDetector(const string &coordinatorLocatorString,
     : ourServerId(ourServerId),
       serverTracker(serverList),
       thread(),
+      threadShouldExit(false),
       pingClient(),
       coordinatorClient(coordinatorLocatorString.c_str()),
       serverList(serverList),
@@ -88,8 +90,10 @@ void
 FailureDetector::halt()
 {
     if (thread) {
-        thread->interrupt();
+        threadShouldExit = true;
+        Fence::sfence();
         thread->join();
+        threadShouldExit = false;
         thread.destroy();
     }
 }
@@ -113,7 +117,9 @@ FailureDetector::detectorThreadEntry(FailureDetector* detector,
 
     while (1) {
         // Check if we have been requested to exit.
-        boost::this_thread::interruption_point();
+        Fence::lfence();
+        if (detector->threadShouldExit)
+            break;
 
         // Drain the list of changes to update our tracker.
         ServerChangeDetails dummy1;

src/FailureDetector.h

@@ -16,6 +16,7 @@
 #ifndef RAMCLOUD_FAILUREDETECTOR_H
 #define RAMCLOUD_FAILUREDETECTOR_H
 
+#include <thread>
 #include <list>
 
 #include "Common.h"
@@ -84,7 +85,10 @@ class FailureDetector {
     ServerTracker<bool>  serverTracker;
 
     /// Failure detector thread
-    Tub<boost::thread>   thread;
+    Tub<std::thread>     thread;
+
+    /// Set by halt() to ask the failure detector thread to exit.
+    bool threadShouldExit;
 
     // Service Clients
     /// PingClient instance

src/Log.cc

@@ -146,7 +146,7 @@ Log::allocateHead()
     //     if you don't know why this is bad.
     LogDigest::SegmentId newHeadId = allocateSegmentId();
 
-    boost::lock_guard<SpinLock> lock(listLock);
+    std::lock_guard<SpinLock> lock(listLock);
 
     if (head != NULL)
         cleanableNewList.push_back(*head);
@@ -207,7 +207,7 @@ Log::allocateHead()
 bool
 Log::isSegmentLive(uint64_t segmentId)
 {
-    boost::lock_guard<SpinLock> lock(listLock);
+    std::lock_guard<SpinLock> lock(listLock);
     return (activeIdMap.find(segmentId) != activeIdMap.end());
 }
 
@@ -504,7 +504,7 @@ void *
 Log::getSegmentMemoryForCleaning(bool useEmergencyReserve)
 {
     if (useEmergencyReserve) {
-        boost::lock_guard<SpinLock> lock(listLock);
+        std::lock_guard<SpinLock> lock(listLock);
 
         if (emergencyCleanerList.empty())
             return NULL;
@@ -523,7 +523,7 @@ Log::getSegmentMemoryForCleaning(bool useEmergencyReserve)
 size_t
 Log::freeListCount()
 {
-    boost::lock_guard<SpinLock> lock(listLock);
+    std::lock_guard<SpinLock> lock(listLock);
 
     // We always save one for the next Log head, so adjust accordingly.
     return (freeList.size() > 0) ? freeList.size() - 1 : freeList.size();
@@ -540,7 +540,7 @@ Log::freeListCount()
 void
 Log::getNewCleanableSegments(SegmentVector& out)
 {
-    boost::lock_guard<SpinLock> lock(listLock);
+    std::lock_guard<SpinLock> lock(listLock);
 
     while (!cleanableNewList.empty()) {
         Segment& s = cleanableNewList.front();
@@ -564,7 +564,7 @@ Log::getNewCleanableSegments(SegmentVector& out)
 void
 Log::cleaningInto(Segment* segment)
 {
-    boost::lock_guard<SpinLock> lock(listLock);
+    std::lock_guard<SpinLock> lock(listLock);
 
     cleaningIntoList.push_back(*segment);
     activeIdMap[segment->getId()] = segment;
@@ -592,7 +592,7 @@ void
 Log::cleaningComplete(SegmentVector& clean,
                       std::vector<void*>& unusedSegmentMemory)
 {
-    boost::lock_guard<SpinLock> lock(listLock);
+    std::lock_guard<SpinLock> lock(listLock);
     bool change = false;
 
     // Return any unused segment memory the cleaner ended up
@@ -673,7 +673,7 @@ uint64_t
 Log::allocateSegmentId()
 {
     // XXX- could just be an atomic op
-    boost::lock_guard<SpinLock> lock(listLock);
+    std::lock_guard<SpinLock> lock(listLock);
     return nextSegmentId++;
 }
 
@@ -792,7 +792,7 @@ Log::locklessAddToFreeList(void *p)
 void *
 Log::getFromFreeList(bool mayUseLastSegment)
 {
-    boost::lock_guard<SpinLock> lock(listLock);
+    std::lock_guard<SpinLock> lock(listLock);
 
     if (freeList.empty())
         throw LogOutOfMemoryException(HERE, "Log is out of space");
@@ -837,7 +837,7 @@ Log::getSegmentFromAddress(const void* address)
 {
     const void *base = Segment::getSegmentBaseAddress(address, segmentCapacity);
 
-    boost::lock_guard<SpinLock> lock(listLock);
+    std::lock_guard<SpinLock> lock(listLock);
 
     if (head != NULL && base == head->getBaseAddress())
         return head;