Merge branch 'master' into balder/reduce-code-visibility-rebased

11 files changed, 66 insertions, 66 deletions

diff --git a/searchlib/src/.gitignore b/searchlib/src/.gitignore
index 3e2fb17989e..b7456dab392 100644
--- a/searchlib/src/.gitignore
+++ b/searchlib/src/.gitignore
@@ -1,5 +1,4 @@
 *.dsp
-*.mak
 Makefile.ini
 config_command.sh
 html
diff --git a/searchlib/src/tests/common/sequencedtaskexecutor/sequencedtaskexecutor_test.cpp b/searchlib/src/tests/common/sequencedtaskexecutor/sequencedtaskexecutor_test.cpp
index 7fd3f33f20a..805a6d3b962 100644
--- a/searchlib/src/tests/common/sequencedtaskexecutor/sequencedtaskexecutor_test.cpp
+++ b/searchlib/src/tests/common/sequencedtaskexecutor/sequencedtaskexecutor_test.cpp
@@ -161,7 +161,7 @@ vespalib::string makeAltComponentId(Fixture &f)
 {
     int tryCnt = 0;
     char altComponentId[20];
-    uint32_t executorId0 = f._threads.getExecutorId("0");
+    ISequencedTaskExecutor::ExecutorId executorId0 = f._threads.getExecutorId("0");
     for (tryCnt = 1; tryCnt < 100; ++tryCnt) {
         sprintf(altComponentId, "%d", tryCnt);
         if (f._threads.getExecutorId(altComponentId) == executorId0) {
@@ -227,7 +227,7 @@ TEST_F("require that executeLambda works", Fixture)
     std::vector<int> res;
     const auto lambda = [i, &res]() mutable
                         { res.push_back(i--); res.push_back(i--); };
-    f._threads.executeLambda(0, lambda);
+    f._threads.executeLambda(ISequencedTaskExecutor::ExecutorId(0), lambda);
     f._threads.sync();
     std::vector<int> exp({5, 4});
     EXPECT_EQUAL(exp, res);
diff --git a/searchlib/src/vespa/searchlib/common/foregroundtaskexecutor.cpp b/searchlib/src/vespa/searchlib/common/foregroundtaskexecutor.cpp
index 1ab3c6b8b51..91ca91be4cd 100644
--- a/searchlib/src/vespa/searchlib/common/foregroundtaskexecutor.cpp
+++ b/searchlib/src/vespa/searchlib/common/foregroundtaskexecutor.cpp
@@ -23,12 +23,12 @@ ForegroundTaskExecutor::~ForegroundTaskExecutor()
 {
 }
 
-uint32_t
+ISequencedTaskExecutor::ExecutorId
 ForegroundTaskExecutor::getExecutorId(uint64_t componentId)
 {
     auto itr = _ids.find(componentId);
     if (itr == _ids.end()) {
-        auto insarg = std::make_pair(componentId, _ids.size() % _threads);
+        auto insarg = std::make_pair(componentId, ExecutorId(_ids.size() % _threads));
         auto insres = _ids.insert(insarg);
         assert(insres.second);
         itr = insres.first;
@@ -37,13 +37,12 @@ ForegroundTaskExecutor::getExecutorId(uint64_t componentId)
 }
 
 void
-ForegroundTaskExecutor::executeTask(uint32_t executorId, vespalib::Executor::Task::UP task)
+ForegroundTaskExecutor::executeTask(ExecutorId id, vespalib::Executor::Task::UP task)
 {
-    assert(executorId < _threads);
+    assert(id.getId() < _threads);
     task->run();
 }
 
-
 void
 ForegroundTaskExecutor::sync()
 {
diff --git a/searchlib/src/vespa/searchlib/common/foregroundtaskexecutor.h b/searchlib/src/vespa/searchlib/common/foregroundtaskexecutor.h
index 10743baf216..cfd135d3fa0 100644
--- a/searchlib/src/vespa/searchlib/common/foregroundtaskexecutor.h
+++ b/searchlib/src/vespa/searchlib/common/foregroundtaskexecutor.h
@@ -17,7 +17,7 @@ namespace search {
 class ForegroundTaskExecutor : public ISequencedTaskExecutor
 {
     const uint32_t                       _threads;
-    vespalib::hash_map<size_t, uint32_t> _ids;
+    vespalib::hash_map<size_t, ExecutorId> _ids;
 public:
     using ISequencedTaskExecutor::getExecutorId;
 
@@ -26,8 +26,8 @@ public:
     ~ForegroundTaskExecutor() override;
 
     uint32_t getNumExecutors() const override { return _threads; }
-    uint32_t getExecutorId(uint64_t componentId) override;
-    void executeTask(uint32_t executorId, vespalib::Executor::Task::UP task) override;
+    ExecutorId getExecutorId(uint64_t componentId) override;
+    void executeTask(ExecutorId id, vespalib::Executor::Task::UP task) override;
     void sync() override;
 };
 
diff --git a/searchlib/src/vespa/searchlib/common/isequencedtaskexecutor.h b/searchlib/src/vespa/searchlib/common/isequencedtaskexecutor.h
index 8488d986bbe..05347e790fb 100644
--- a/searchlib/src/vespa/searchlib/common/isequencedtaskexecutor.h
+++ b/searchlib/src/vespa/searchlib/common/isequencedtaskexecutor.h
@@ -14,6 +14,17 @@ namespace search {
 class ISequencedTaskExecutor
 {
 public:
+    class ExecutorId {
+    public:
+        ExecutorId() : ExecutorId(0) { }
+        explicit ExecutorId(uint32_t id) : _id(id) { }
+        uint32_t getId() const { return _id; }
+        bool operator != (ExecutorId rhs) const { return _id != rhs._id; }
+        bool operator == (ExecutorId rhs) const { return _id == rhs._id; }
+        bool operator < (ExecutorId rhs) const { return _id < rhs._id; }
+    private:
+        uint32_t _id;
+    };
     virtual ~ISequencedTaskExecutor() { }
 
     /**
@@ -23,10 +34,10 @@ public:
      * @param componentId   component id
      * @return              executor id
      */
-    virtual uint32_t getExecutorId(uint64_t componentId) = 0;
+    virtual ExecutorId getExecutorId(uint64_t componentId) = 0;
     virtual uint32_t getNumExecutors() const = 0;
 
-    uint32_t getExecutorId(vespalib::stringref componentId) {
+    ExecutorId getExecutorId(vespalib::stringref componentId) {
         vespalib::hash<vespalib::stringref> hashfun;
         return getExecutorId(hashfun(componentId));
     }
@@ -35,22 +46,22 @@ public:
      * Schedule a task to run after all previously scheduled tasks with
      * same id.
      *
-     * @param executorId which internal executor to use
-     * @param task       unique pointer to the task to be executed
+     * @param id     which internal executor to use
+     * @param task   unique pointer to the task to be executed
      */
-    virtual void executeTask(uint32_t exeucutorId, vespalib::Executor::Task::UP task) = 0;
+    virtual void executeTask(ExecutorId id, vespalib::Executor::Task::UP task) = 0;
 
     /**
      * Wrap lambda function into a task and schedule it to be run.
      * Caller must ensure that pointers and references are valid and
      * call sync before tearing down pointed to/referenced data.
       *
-     * @param executorId    which internal executor to use
-     * @param function      function to be wrapped in a task and later executed
+     * @param id        which internal executor to use
+     * @param function  function to be wrapped in a task and later executed
      */
     template <class FunctionType>
-    void executeLambda(uint32_t executorId, FunctionType &&function) {
-        executeTask(executorId, vespalib::makeLambdaTask(std::forward<FunctionType>(function)));
+    void executeLambda(ExecutorId id, FunctionType &&function) {
+        executeTask(id, vespalib::makeLambdaTask(std::forward<FunctionType>(function)));
     }
     /**
      * Wait for all scheduled tasks to complete.
@@ -68,8 +79,8 @@ public:
      */
     template <class FunctionType>
     void execute(uint64_t componentId, FunctionType &&function) {
-        uint32_t executorId = getExecutorId(componentId);
-        executeTask(executorId, vespalib::makeLambdaTask(std::forward<FunctionType>(function)));
+        ExecutorId id = getExecutorId(componentId);
+        executeTask(id, vespalib::makeLambdaTask(std::forward<FunctionType>(function)));
     }
 
     /**
@@ -83,8 +94,8 @@ public:
      */
     template <class FunctionType>
     void execute(vespalib::stringref componentId, FunctionType &&function) {
-        uint32_t executorId = getExecutorId(componentId);
-        executeTask(executorId, vespalib::makeLambdaTask(std::forward<FunctionType>(function)));
+        ExecutorId id = getExecutorId(componentId);
+        executeTask(id, vespalib::makeLambdaTask(std::forward<FunctionType>(function)));
     }
 };
 
diff --git a/searchlib/src/vespa/searchlib/common/sequencedtaskexecutor.cpp b/searchlib/src/vespa/searchlib/common/sequencedtaskexecutor.cpp
index 953449ee496..5306cabba8c 100644
--- a/searchlib/src/vespa/searchlib/common/sequencedtaskexecutor.cpp
+++ b/searchlib/src/vespa/searchlib/common/sequencedtaskexecutor.cpp
@@ -37,12 +37,12 @@ SequencedTaskExecutor::setTaskLimit(uint32_t taskLimit)
     }
 }
 
-uint32_t
+ISequencedTaskExecutor::ExecutorId
 SequencedTaskExecutor::getExecutorId(uint64_t componentId)
 {
     auto itr = _ids.find(componentId);
     if (itr == _ids.end()) {
-        auto insarg = std::make_pair(componentId, _ids.size() % _executors.size());
+        auto insarg = std::make_pair(componentId, ExecutorId(_ids.size() % _executors.size()));
         auto insres = _ids.insert(insarg);
         assert(insres.second);
         itr = insres.first;
@@ -51,10 +51,10 @@ SequencedTaskExecutor::getExecutorId(uint64_t componentId)
 }
 
 void
-SequencedTaskExecutor::executeTask(uint32_t executorId, vespalib::Executor::Task::UP task)
+SequencedTaskExecutor::executeTask(ExecutorId id, vespalib::Executor::Task::UP task)
 {
-    assert(executorId < _executors.size());
-    vespalib::ThreadStackExecutorBase &executor(*_executors[executorId]);
+    assert(id.getId() < _executors.size());
+    vespalib::ThreadStackExecutorBase &executor(*_executors[id.getId()]);
     auto rejectedTask = executor.execute(std::move(task));
     assert(!rejectedTask);
 }
diff --git a/searchlib/src/vespa/searchlib/common/sequencedtaskexecutor.h b/searchlib/src/vespa/searchlib/common/sequencedtaskexecutor.h
index 0c455225c89..41209da09ef 100644
--- a/searchlib/src/vespa/searchlib/common/sequencedtaskexecutor.h
+++ b/searchlib/src/vespa/searchlib/common/sequencedtaskexecutor.h
@@ -20,7 +20,7 @@ class SequencedTaskExecutor : public ISequencedTaskExecutor
 {
     using Stats = vespalib::ExecutorStats;
     std::vector<std::shared_ptr<vespalib::BlockingThreadStackExecutor>> _executors;
-    vespalib::hash_map<size_t, size_t> _ids;
+    vespalib::hash_map<size_t, ExecutorId> _ids;
 public:
     using ISequencedTaskExecutor::getExecutorId;
 
@@ -29,8 +29,8 @@ public:
 
     void setTaskLimit(uint32_t taskLimit);
     uint32_t getNumExecutors() const override { return _executors.size(); }
-    uint32_t getExecutorId(uint64_t componentId) override;
-    void executeTask(uint32_t executorId, vespalib::Executor::Task::UP task) override;
+    ExecutorId getExecutorId(uint64_t componentId) override;
+    void executeTask(ExecutorId id, vespalib::Executor::Task::UP task) override;
     void sync() override;
     Stats getStats();
 };
diff --git a/searchlib/src/vespa/searchlib/common/sequencedtaskexecutorobserver.cpp b/searchlib/src/vespa/searchlib/common/sequencedtaskexecutorobserver.cpp
index e11b39de5ed..b693c976ebe 100644
--- a/searchlib/src/vespa/searchlib/common/sequencedtaskexecutorobserver.cpp
+++ b/searchlib/src/vespa/searchlib/common/sequencedtaskexecutorobserver.cpp
@@ -2,8 +2,7 @@
 
 #include "sequencedtaskexecutorobserver.h"
 
-namespace search
-{
+namespace search {
 
 SequencedTaskExecutorObserver::SequencedTaskExecutorObserver(ISequencedTaskExecutor &executor)
     : _executor(executor),
@@ -14,26 +13,23 @@ SequencedTaskExecutorObserver::SequencedTaskExecutorObserver(ISequencedTaskExecu
 {
 }
 
-SequencedTaskExecutorObserver::~SequencedTaskExecutorObserver()
-{
-}
+SequencedTaskExecutorObserver::~SequencedTaskExecutorObserver() = default;
 
-uint32_t
+ISequencedTaskExecutor::ExecutorId
 SequencedTaskExecutorObserver::getExecutorId(uint64_t componentId)
 {
     return _executor.getExecutorId(componentId);
 }
 
 void
-SequencedTaskExecutorObserver::executeTask(uint32_t executorId,
-                                           vespalib::Executor::Task::UP task)
+SequencedTaskExecutorObserver::executeTask(ExecutorId id, vespalib::Executor::Task::UP task)
 {
     ++_executeCnt;
     {
         std::lock_guard<std::mutex> guard(_mutex);
-        _executeHistory.emplace_back(executorId);
+        _executeHistory.emplace_back(id.getId());
     }
-    _executor.executeTask(executorId, std::move(task));
+    _executor.executeTask(id, std::move(task));
 }
 
 void
diff --git a/searchlib/src/vespa/searchlib/common/sequencedtaskexecutorobserver.h b/searchlib/src/vespa/searchlib/common/sequencedtaskexecutorobserver.h
index e7cbe7f54bc..b4561148bca 100644
--- a/searchlib/src/vespa/searchlib/common/sequencedtaskexecutorobserver.h
+++ b/searchlib/src/vespa/searchlib/common/sequencedtaskexecutorobserver.h
@@ -26,8 +26,8 @@ public:
     virtual ~SequencedTaskExecutorObserver() override;
 
     uint32_t getNumExecutors() const override { return _executor.getNumExecutors(); }
-    uint32_t getExecutorId(uint64_t componentId) override;
-    void executeTask(uint32_t executorId, vespalib::Executor::Task::UP task) override;
+    ExecutorId getExecutorId(uint64_t componentId) override;
+    void executeTask(ExecutorId id, vespalib::Executor::Task::UP task) override;
     void sync() override;
 
     uint32_t getExecuteCnt() const { return _executeCnt; }
diff --git a/searchlib/src/vespa/searchlib/common/threaded_compactable_lid_space.cpp b/searchlib/src/vespa/searchlib/common/threaded_compactable_lid_space.cpp
index 079a1f493de..defb537be0e 100644
--- a/searchlib/src/vespa/searchlib/common/threaded_compactable_lid_space.cpp
+++ b/searchlib/src/vespa/searchlib/common/threaded_compactable_lid_space.cpp
@@ -6,19 +6,18 @@
 #include "isequencedtaskexecutor.h"
 #include <future>
 
-namespace search {
-namespace common {
+namespace search::common {
 
-ThreadedCompactableLidSpace::ThreadedCompactableLidSpace(std::shared_ptr<ICompactableLidSpace> target, ISequencedTaskExecutor &executor, uint32_t executorId)
+ThreadedCompactableLidSpace::ThreadedCompactableLidSpace(std::shared_ptr<ICompactableLidSpace> target,
+                                                         ISequencedTaskExecutor &executor,
+                                                         ISequencedTaskExecutor::ExecutorId id)
     : _target(target),
       _executor(executor),
-      _executorId(executorId)
+      _executorId(id)
 {
 }
 
-ThreadedCompactableLidSpace::~ThreadedCompactableLidSpace()
-{
-}
+ThreadedCompactableLidSpace::~ThreadedCompactableLidSpace() = default;
 
 void
 ThreadedCompactableLidSpace::compactLidSpace(uint32_t wantedDocLidLimit)
@@ -51,4 +50,3 @@ ThreadedCompactableLidSpace::shrinkLidSpace()
 }
 
 }
-}
diff --git a/searchlib/src/vespa/searchlib/common/threaded_compactable_lid_space.h b/searchlib/src/vespa/searchlib/common/threaded_compactable_lid_space.h
index 84c9c0d6495..02d54acf666 100644
--- a/searchlib/src/vespa/searchlib/common/threaded_compactable_lid_space.h
+++ b/searchlib/src/vespa/searchlib/common/threaded_compactable_lid_space.h
@@ -3,13 +3,10 @@
 #pragma once
 
 #include "i_compactable_lid_space.h"
+#include "isequencedtaskexecutor.h"
 #include <memory>
 
-namespace search {
-
-class ISequencedTaskExecutor;
-
-namespace common {
+namespace search::common {
 
 /**
  * Adapter class for a component that has a lid space that can be
@@ -19,16 +16,16 @@ namespace common {
 class ThreadedCompactableLidSpace : public ICompactableLidSpace
 {
     std::shared_ptr<ICompactableLidSpace> _target;
-    ISequencedTaskExecutor &_executor;
-    uint32_t                _executorId;
+    ISequencedTaskExecutor               &_executor;
+    ISequencedTaskExecutor::ExecutorId    _executorId;
 public:
-    ThreadedCompactableLidSpace(std::shared_ptr<ICompactableLidSpace> target, ISequencedTaskExecutor &executor, uint32_t executorId);
-    virtual ~ThreadedCompactableLidSpace() override;
-    virtual void compactLidSpace(uint32_t wantedDocLidLimit) override;
-    virtual bool canShrinkLidSpace() const override;
-    virtual size_t getEstimatedShrinkLidSpaceGain() const override;
-    virtual void shrinkLidSpace() override;
+    ThreadedCompactableLidSpace(std::shared_ptr<ICompactableLidSpace> target, ISequencedTaskExecutor &executor,
+                                ISequencedTaskExecutor::ExecutorId executorId);
+    ~ThreadedCompactableLidSpace() override;
+    void compactLidSpace(uint32_t wantedDocLidLimit) override;
+    bool canShrinkLidSpace() const override;
+    size_t getEstimatedShrinkLidSpaceGain() const override;
+    void shrinkLidSpace() override;
 };
 
 }
-}