do not use workers on small lists of pending objects

Preparing workers for parallel processing has quite a bit of
setup overhead. It is therefore not worth doing unless there
are enough objects to process to make the overhead worth it.

This speeds up in particular the tests where only a handful
of objects is imported per run.

Author: lonvia

src/osmdata.cpp

@@ -302,25 +302,33 @@ class multithreaded_processor
             ids_queued, type, m_clones.size()));
 
         util::timer_t timer;
-        std::vector<std::future<void>> workers;
 
-        for (auto const &clone : m_clones) {
-            workers.push_back(std::async(std::launch::async, run,
-                                         std::cref(clone), &list, &m_mutex,
-                                         function));
-        }
-        workers.push_back(
-            std::async(std::launch::async, print_stats, &list, &m_mutex));
-
-        for (auto &worker : workers) {
-            try {
-                worker.get();
-            } catch (...) {
-                // Drain the queue, so that the other workers finish early.
-                m_mutex.lock();
-                list.clear();
-                m_mutex.unlock();
-                throw;
+        if (ids_queued < 100) {
+            for (auto const oid : list) {
+                (m_clones[0].get()->*function)(oid);
+            }
+            m_clones[0]->sync();
+        } else {
+            std::vector<std::future<void>> workers;
+
+            for (auto const &clone : m_clones) {
+                workers.push_back(std::async(std::launch::async, run,
+                                             std::cref(clone), &list, &m_mutex,
+                                             function));
+            }
+            workers.push_back(
+                std::async(std::launch::async, print_stats, &list, &m_mutex));
+
+            for (auto &worker : workers) {
+                try {
+                    worker.get();
+                } catch (...) {
+                    // Drain the queue, so that the other workers finish early.
+                    m_mutex.lock();
+                    list.clear();
+                    m_mutex.unlock();
+                    throw;
+                }
             }
         }