Merge non-results from worker threads to put less load on Serializer.

[plocate] / plocate.cpp

diff --git a/plocate.cpp b/plocate.cpp
index e31345852341f2a7218a435b873ec88303888a72..926bbf1977831562217829cc07e7aaddf56ca4f8 100644 (file)
--- a/plocate.cpp
+++ b/plocate.cpp
@@ -417,7 +417,12 @@ struct WorkerThread {
        // since a lock on it becomes a huge choke point if there are
        // lots of threads.
        mutex result_mu;
-       vector<tuple<uint64_t, uint64_t, string>> results;
+       struct Result {
+               uint64_t seq;
+               uint64_t skip;
+               string msg;
+       };
+       vector<Result> results;
 };
 
 class WorkerThreadReceiver : public ResultReceiver {
@@ -427,7 +432,11 @@ public:
        void print(uint64_t seq, uint64_t skip, const string msg) override
        {
                lock_guard<mutex> lock(wt->result_mu);
-               wt->results.emplace_back(seq, skip, move(msg));
+               if (msg.empty() && !wt->results.empty() && wt->results.back().seq + wt->results.back().skip == seq) {
+                       wt->results.back().skip += skip;
+               } else {
+                       wt->results.emplace_back(WorkerThread::Result{ seq, skip, move(msg) });
+               }
        }
 
 private:
@@ -436,13 +445,13 @@ private:
 
 void deliver_results(WorkerThread *wt, Serializer *serializer)
 {
-       vector<tuple<uint64_t, uint64_t, string>> results;
+       vector<WorkerThread::Result> results;
        {
                lock_guard<mutex> lock(wt->result_mu);
                results = move(wt->results);
        }
-       for (const auto &result : results) {
-               serializer->print(get<0>(result), get<1>(result), move(get<2>(result)));
+       for (const WorkerThread::Result &result : results) {
+               serializer->print(result.seq, result.skip, move(result.msg));
        }
 }