Merge pull request #1994 from Expensify/main

Update expensify_prod branch

BedrockServer.cpp

@@ -14,7 +14,6 @@
 #include <libstuff/libstuff.h>
 #include <libstuff/SRandom.h>
 #include <libstuff/AutoTimer.h>
-#include <libstuff/ResourceMonitorThread.h>
 #include <PageLockGuard.h>
 #include <sqlitecluster/SQLitePeer.h>
 
@@ -118,9 +117,9 @@ void BedrockServer::sync()
     // our worker threads now. We don't wait until the node is `LEADING` or `FOLLOWING`, as it's state can change while
     // it's running, and our workers will have to maintain awareness of that state anyway.
     SINFO("Starting " << workerThreads << " worker threads.");
-    list<ResourceMonitorThread> workerThreadList;
+    list<thread> workerThreadList;
     for (int threadId = 0; threadId < workerThreads; threadId++) {
-        workerThreadList.emplace_back([this, threadId](){this->worker(threadId);});
+        workerThreadList.emplace_back(&BedrockServer::worker, this, threadId);
     }
 
     // Now we jump into our main command processing loop.
@@ -1339,7 +1338,7 @@ BedrockServer::BedrockServer(const SData& args_)
 
     // Start the sync thread, which will start the worker threads.
     SINFO("Launching sync thread '" << _syncThreadName << "'");
-    _syncThread = ResourceMonitorThread(&BedrockServer::syncWrapper, this);
+    _syncThread = thread(&BedrockServer::syncWrapper, this);
 }
 
 BedrockServer::~BedrockServer() {
@@ -1909,7 +1908,7 @@ void BedrockServer::_control(unique_ptr<BedrockCommand>& command) {
         if (__quiesceThread) {
             response.methodLine = "400 Already Blocked";
         } else {
-            __quiesceThread = new ResourceMonitorThread([&]() {
+            __quiesceThread = new thread([&]() {
                 shared_ptr<SQLitePool> dbPoolCopy = _dbPool;
                 if (dbPoolCopy) {
                     SQLiteScopedHandle dbScope(*_dbPool, _dbPool->getIndex());
@@ -2139,7 +2138,7 @@ void BedrockServer::_acceptSockets() {
                 bool threadStarted = false;
                 while (!threadStarted) {
                     try {
-                        t = ResourceMonitorThread(&BedrockServer::handleSocket, this, move(socket), port == _controlPort, port == _commandPortPublic, port == _commandPortPrivate);
+                        t = thread(&BedrockServer::handleSocket, this, move(socket), port == _controlPort, port == _commandPortPublic, port == _commandPortPrivate);
                         threadStarted = true;
                     } catch (const system_error& e) {
                         // We don't care about this lock here from a performance perspective, it only happens when we

plugins/DB.cpp

@@ -72,6 +72,10 @@ bool BedrockDBCommand::peek(SQLite& db) {
         return false;
     }
 
+    // We rollback here because if we are in a transaction and the querytakes long (which the queries in this command can)
+    // it prevents sqlite from checkpointing and if we accumulate a lot of things to checkpoint, things become slow
+    ((SQLite&) db).rollback();
+
     // Attempt the read-only query
     SQResult result;
     if (!db.read(query, result)) {

sqlitecluster/SQLiteClusterMessenger.cpp

@@ -2,7 +2,6 @@
 #include <sqlitecluster/SQLiteClusterMessenger.h>
 #include <sqlitecluster/SQLiteNode.h>
 #include <sqlitecluster/SQLitePeer.h>
-#include <libstuff/ResourceMonitorThread.h>
 
 #include <unistd.h>
 #include <fcntl.h>
@@ -70,7 +69,7 @@ SQLiteClusterMessenger::WaitForReadyResult SQLiteClusterMessenger::waitForReady(
 }
 
 vector<SData> SQLiteClusterMessenger::runOnAll(const SData& cmd) {
-    list<ResourceMonitorThread> threads;
+    list<thread> threads;
     const list<STable> peerInfo = _node->getPeerInfo();
     vector<SData> results(peerInfo.size());
     atomic<size_t> index = 0;

sqlitecluster/SQLiteNode.cpp

@@ -4,7 +4,6 @@
 
 #include <libstuff/AutoScopeOnPrepare.h>
 #include <libstuff/libstuff.h>
-#include <libstuff/ResourceMonitorThread.h>
 #include <libstuff/SRandom.h>
 #include <libstuff/SQResult.h>
 #include <sqlitecluster/SQLiteCommand.h>
@@ -1507,7 +1506,7 @@ void SQLiteNode::_onMESSAGE(SQLitePeer* peer, const SData& message) {
             } else {
                 _pendingSynchronizeResponses++;
                 static atomic<size_t> synchronizeCount(0);
-                ResourceMonitorThread([message, peer, currentSynchronizeCount = synchronizeCount++, this] () {
+                thread([message, peer, currentSynchronizeCount = synchronizeCount++, this] () {
                     SInitialize("synchronize" + to_string(currentSynchronizeCount));
                     SData response("SYNCHRONIZE_RESPONSE");
                     SQLiteScopedHandle dbScope(*_dbPool, _dbPool->getIndex());