GC legacy lid-space-compaction and bucket-move jobs.

6 files changed, 10 insertions, 654 deletions

diff --git a/searchcore/src/vespa/searchcore/proton/server/CMakeLists.txt b/searchcore/src/vespa/searchcore/proton/server/CMakeLists.txt
index 86d238c7554..9d359590912 100644
--- a/searchcore/src/vespa/searchcore/proton/server/CMakeLists.txt
+++ b/searchcore/src/vespa/searchcore/proton/server/CMakeLists.txt
@@ -5,7 +5,6 @@ vespa_add_library(searchcore_server STATIC
     bootstrapconfig.cpp
     bootstrapconfigmanager.cpp
     buckethandler.cpp
-    bucketmovejob.cpp
     bucketmovejobv2.cpp
     clusterstatehandler.cpp
     combiningfeedview.cpp
@@ -58,7 +57,6 @@ vespa_add_library(searchcore_server STATIC
     ireplayconfig.cpp
     job_tracked_maintenance_job.cpp
     lid_space_compaction_handler.cpp
-    lid_space_compaction_job.cpp
     lid_space_compaction_job_base.cpp
     lid_space_compaction_job_take2.cpp
     maintenance_controller_explorer.cpp
diff --git a/searchcore/src/vespa/searchcore/proton/server/bucketmovejob.cpp b/searchcore/src/vespa/searchcore/proton/server/bucketmovejob.cpp
deleted file mode 100644
index 1ca4c307bfb..00000000000
--- a/searchcore/src/vespa/searchcore/proton/server/bucketmovejob.cpp
+++ /dev/null
@@ -1,370 +0,0 @@
-// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#include "bucketmovejob.h"
-#include "imaintenancejobrunner.h"
-#include "ibucketstatechangednotifier.h"
-#include "iclusterstatechangednotifier.h"
-#include "maintenancedocumentsubdb.h"
-#include "i_disk_mem_usage_notifier.h"
-#include "ibucketmodifiedhandler.h"
-#include "move_operation_limiter.h"
-#include <vespa/searchcore/proton/bucketdb/i_bucket_create_notifier.h>
-#include <vespa/searchcore/proton/documentmetastore/i_document_meta_store.h>
-
-#include <vespa/log/log.h>
-LOG_SETUP(".proton.server.bucketmovejob");
-
-using document::BucketId;
-using storage::spi::BucketInfo;
-using vespalib::Trinary;
-
-namespace proton {
-
-namespace {
-
-const char *
-toStr(bool v) {
-    return (v ? "T" : "F");
-}
-
-const char *
-toStr(Trinary v) {
-    return (v == Trinary::True) ? "T" : ((v == Trinary::False) ? "F" : "U");
-}
-
-}
-
-void
-BucketMoveJob::checkBucket(const BucketId &bucket,
-                           ScanIterator &itr,
-                           DocumentBucketMover &mover,
-                           IFrozenBucketHandler::ExclusiveBucketGuard::UP & bucketGuard)
-{
-    const bool hasReadyDocs = itr.hasReadyBucketDocs();
-    const bool hasNotReadyDocs = itr.hasNotReadyBucketDocs();
-    if (!hasReadyDocs && !hasNotReadyDocs) {
-        return; // No documents for bucket in ready or notready subdbs
-    }
-    const bool isActive = itr.isActive();
-    // No point in moving buckets when node is retired and everything will be deleted soon.
-    // However, allow moving of explicitly activated buckets, as this implies a lack of other good replicas.
-    if (_calc->nodeRetired() && !isActive) {
-        return;
-    }
-    Trinary shouldBeReady = _calc->shouldBeReady(document::Bucket(_bucketSpace, bucket));
-    if (shouldBeReady == vespalib::Trinary::Undefined) {
-        return;
-    }
-    const bool wantReady = (shouldBeReady == Trinary::True) || isActive;
-    LOG(spam, "checkBucket(): bucket(%s), shouldBeReady(%s), active(%s)",
-              bucket.toString().c_str(), toStr(shouldBeReady), toStr(isActive));
-    if (wantReady) {
-        if (!hasNotReadyDocs)
-            return; // No notready bucket to make ready
-    } else {
-        if (!hasReadyDocs)
-            return; // No ready bucket to make notready
-    }
-    bucketGuard = _frozenBuckets.acquireExclusiveBucket(bucket);
-    if ( ! bucketGuard ) {
-        LOG(debug, "checkBucket(): delay frozen bucket: (%s)", bucket.toString().c_str());
-        _delayedBucketsFrozen.insert(bucket);
-        _delayedBuckets.erase(bucket);
-        return;
-    }
-    const MaintenanceDocumentSubDB &source(wantReady ? _notReady : _ready);
-    const MaintenanceDocumentSubDB &target(wantReady ? _ready : _notReady);
-    LOG(debug, "checkBucket(): mover.setupForBucket(%s, source:%u, target:%u)",
-        bucket.toString().c_str(), source.sub_db_id(), target.sub_db_id());
-    mover.setupForBucket(bucket, &source, target.sub_db_id(), _moveHandler);
-}
-
-BucketMoveJob::ScanResult
-BucketMoveJob::scanBuckets(size_t maxBucketsToScan, IFrozenBucketHandler::ExclusiveBucketGuard::UP & bucketGuard)
-{
-    size_t bucketsScanned = 0;
-    bool passDone = false;
-    ScanIterator itr(_ready.meta_store()->getBucketDB().takeGuard(),
-            _scanPass, _scanPos._lastBucket, _endPos._lastBucket);
-    BucketId bucket;
-    for (; itr.valid() &&
-             bucketsScanned < maxBucketsToScan && _mover.bucketDone();
-         ++itr, ++bucketsScanned)
-    {
-        bucket = itr.getBucket();
-        _scanPos._lastBucket = bucket;
-        checkBucket(bucket, itr, _mover, bucketGuard);
-    }
-    if (!itr.valid()) {
-        passDone = true;
-        _scanPos._lastBucket = BucketId();
-    }
-    return ScanResult(bucketsScanned, passDone);
-}
-
-bool
-BucketMoveJob::moveDocuments(DocumentBucketMover &mover,
-                             size_t maxDocsToMove,
-                             IFrozenBucketHandler::ExclusiveBucketGuard::UP & bucketGuard)
-{
-    if ( ! bucketGuard ) {
-        bucketGuard = _frozenBuckets.acquireExclusiveBucket(mover.getBucket());
-        if (! bucketGuard) {
-            maybeDelayMover(mover, mover.getBucket());
-            return true;
-        }
-    }
-    assert(mover.getBucket() == bucketGuard->getBucket());
-    if ( ! mover.moveDocuments(maxDocsToMove)) {
-        return false;
-    }
-    if (mover.bucketDone()) {
-        _modifiedHandler.notifyBucketModified(mover.getBucket());
-    }
-    return true;
-}
-
-namespace {
-
-bool
-blockedDueToClusterState(const std::shared_ptr<IBucketStateCalculator> &calc)
-{
-    bool clusterUp = calc.get() != nullptr && calc->clusterUp();
-    bool nodeUp = calc.get() != nullptr && calc->nodeUp();
-    bool nodeInitializing = calc.get() != nullptr && calc->nodeInitializing();
-    return !(clusterUp && nodeUp && !nodeInitializing);
-}
-
-}
-
-BucketMoveJob::
-BucketMoveJob(const std::shared_ptr<IBucketStateCalculator> &calc,
-              IDocumentMoveHandler &moveHandler,
-              IBucketModifiedHandler &modifiedHandler,
-              const MaintenanceDocumentSubDB &ready,
-              const MaintenanceDocumentSubDB &notReady,
-              IFrozenBucketHandler &frozenBuckets,
-              bucketdb::IBucketCreateNotifier &bucketCreateNotifier,
-              IClusterStateChangedNotifier &clusterStateChangedNotifier,
-              IBucketStateChangedNotifier &bucketStateChangedNotifier,
-              IDiskMemUsageNotifier &diskMemUsageNotifier,
-              const BlockableMaintenanceJobConfig &blockableConfig,
-              const vespalib::string &docTypeName,
-              document::BucketSpace bucketSpace)
-    : BlockableMaintenanceJob("move_buckets." + docTypeName, vespalib::duration::zero(), vespalib::duration::zero(), blockableConfig),
-      IClusterStateChangedHandler(),
-      IBucketFreezeListener(),
-      bucketdb::IBucketCreateListener(),
-      IBucketStateChangedHandler(),
-      IDiskMemUsageListener(),
-      _calc(calc),
-      _moveHandler(moveHandler),
-      _modifiedHandler(modifiedHandler),
-      _ready(ready),
-      _notReady(notReady),
-      _mover(getLimiter(), _ready.meta_store()->getBucketDB()),
-      _doneScan(false),
-      _scanPos(),
-      _scanPass(ScanPass::FIRST),
-      _endPos(),
-      _bucketSpace(bucketSpace),
-      _delayedBuckets(),
-      _delayedBucketsFrozen(),
-      _frozenBuckets(frozenBuckets),
-      _bucketCreateNotifier(bucketCreateNotifier),
-      _delayedMover(getLimiter(), _ready.meta_store()->getBucketDB()),
-      _clusterStateChangedNotifier(clusterStateChangedNotifier),
-      _bucketStateChangedNotifier(bucketStateChangedNotifier),
-      _diskMemUsageNotifier(diskMemUsageNotifier)
-{
-    if (blockedDueToClusterState(_calc)) {
-        setBlocked(BlockedReason::CLUSTER_STATE);
-    }
-
-    _frozenBuckets.addListener(this);
-    _bucketCreateNotifier.addListener(this);
-    _clusterStateChangedNotifier.addClusterStateChangedHandler(this);
-    _bucketStateChangedNotifier.addBucketStateChangedHandler(this);
-    _diskMemUsageNotifier.addDiskMemUsageListener(this);
-}
-
-BucketMoveJob::~BucketMoveJob()
-{
-    _frozenBuckets.removeListener(this);
-    _bucketCreateNotifier.removeListener(this);
-    _clusterStateChangedNotifier.removeClusterStateChangedHandler(this);
-    _bucketStateChangedNotifier.removeBucketStateChangedHandler(this);
-    _diskMemUsageNotifier.removeDiskMemUsageListener(this);
-}
-
-void
-BucketMoveJob::maybeCancelMover(DocumentBucketMover &mover)
-{
-    // Cancel bucket if moving in wrong direction
-    if (!mover.bucketDone()) {
-        bool ready = mover.getSource() == &_ready;
-        Trinary shouldBeReady = _calc->shouldBeReady(document::Bucket(_bucketSpace, mover.getBucket()));
-        if (isBlocked() ||
-            (shouldBeReady == Trinary::Undefined) ||
-            (ready == (shouldBeReady == Trinary::True)))
-        {
-            mover.cancel();
-        }
-    }
-}
-
-void
-BucketMoveJob::maybeDelayMover(DocumentBucketMover &mover, BucketId bucket)
-{
-    // Delay bucket if being frozen.
-    if (!mover.bucketDone() && bucket == mover.getBucket()) {
-        mover.cancel();
-        _delayedBucketsFrozen.insert(bucket);
-        _delayedBuckets.erase(bucket);
-    }
-}
-
-void
-BucketMoveJob::notifyThawedBucket(const BucketId &bucket)
-{
-    if (_delayedBucketsFrozen.erase(bucket) != 0u) {
-        _delayedBuckets.insert(bucket);
-        considerRun();
-    }
-}
-
-void
-BucketMoveJob::deactivateBucket(BucketId bucket)
-{
-    _delayedBuckets.insert(bucket);
-}
-
-void
-BucketMoveJob::activateBucket(BucketId bucket)
-{
-    bucketdb::Guard notReadyBdb(_notReady.meta_store()->getBucketDB().takeGuard());
-    if (notReadyBdb->get(bucket).getDocumentCount() == 0) {
-        return; // notready bucket already empty. This is the normal case.
-    }
-    _delayedBuckets.insert(bucket);
-}
-
-void
-BucketMoveJob::notifyCreateBucket(const bucketdb::Guard &, const BucketId &bucket)
-{
-    _delayedBuckets.insert(bucket);
-    considerRun();
-}
-
-void
-BucketMoveJob::changedCalculator()
-{
-    if (done()) {
-        _scanPos = ScanPosition();
-        _endPos = ScanPosition();
-    } else {
-        _endPos = _scanPos;
-    }
-    _doneScan = false;
-    _scanPass = ScanPass::FIRST;
-    maybeCancelMover(_mover);
-    maybeCancelMover(_delayedMover);
-}
-
-bool
-BucketMoveJob::scanAndMove(size_t maxBucketsToScan, size_t maxDocsToMove)
-{
-    IFrozenBucketHandler::ExclusiveBucketGuard::UP bucketGuard;
-    // Look for delayed bucket to be processed now
-    while (!_delayedBuckets.empty() && _delayedMover.bucketDone()) {
-        const BucketId bucket = *_delayedBuckets.begin();
-        _delayedBuckets.erase(_delayedBuckets.begin());
-        ScanIterator itr(_ready.meta_store()->getBucketDB().takeGuard(), bucket);
-        if (itr.getBucket() == bucket) {
-            checkBucket(bucket, itr, _delayedMover, bucketGuard);
-        }
-    }
-    if (!_delayedMover.bucketDone()) {
-        return moveDocuments(_delayedMover, maxDocsToMove, bucketGuard);
-    }
-    if (_mover.bucketDone()) {
-        size_t bucketsScanned = 0;
-        for (;;) {
-            if (_mover.bucketDone()) {
-                ScanResult res = scanBuckets(maxBucketsToScan - bucketsScanned, bucketGuard);
-                bucketsScanned += res.first;
-                if (res.second) {
-                    if (_scanPass == ScanPass::FIRST &&
-                        _endPos.validBucket()) {
-                        _scanPos = ScanPosition();
-                        _scanPass = ScanPass::SECOND;
-                    } else {
-                        _doneScan = true;
-                        break;
-                    }
-                }
-            }
-            if (!_mover.bucketDone() || bucketsScanned >= maxBucketsToScan) {
-                break;
-            }
-        }
-    }
-    if (!_mover.bucketDone()) {
-        return moveDocuments(_mover, maxDocsToMove, bucketGuard);
-    }
-    return true;
-}
-
-bool
-BucketMoveJob::run()
-{
-    if (isBlocked() || done()) {
-        return true; // indicate work is done, since node state is bad
-    }
-    /// Returning false here will immediately post the job back on the executor. This will give a busy loop,
-    /// but this is considered fine as it is very rare and it will be intermingled with multiple feed operations.
-    if ( ! scanAndMove(200, 1) ) {
-        return false;
-    }
-
-    if (isBlocked(BlockedReason::OUTSTANDING_OPS)) {
-        return true;
-    }
-    return done();
-}
-
-void
-BucketMoveJob::notifyClusterStateChanged(const std::shared_ptr<IBucketStateCalculator> &newCalc)
-{
-    // Called by master write thread
-    _calc = newCalc;
-    changedCalculator();
-    if (blockedDueToClusterState(_calc)) {
-        setBlocked(BlockedReason::CLUSTER_STATE);
-    } else {
-        unBlock(BlockedReason::CLUSTER_STATE);
-    }
-}
-
-void
-BucketMoveJob::notifyBucketStateChanged(const BucketId &bucketId, BucketInfo::ActiveState newState)
-{
-    // Called by master write thread
-    if (newState == BucketInfo::NOT_ACTIVE) {
-        deactivateBucket(bucketId);
-    } else {
-        activateBucket(bucketId);
-    }
-    if (!done()) {
-        considerRun();
-    }
-}
-
-void
-BucketMoveJob::notifyDiskMemUsage(DiskMemUsageState state)
-{
-    // Called by master write thread
-    internalNotifyDiskMemUsage(state);
-}
-
-} // namespace proton
diff --git a/searchcore/src/vespa/searchcore/proton/server/bucketmovejob.h b/searchcore/src/vespa/searchcore/proton/server/bucketmovejob.h
deleted file mode 100644
index 7ef1a491667..00000000000
--- a/searchcore/src/vespa/searchcore/proton/server/bucketmovejob.h
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#pragma once
-
-#include "blockable_maintenance_job.h"
-#include "documentbucketmover.h"
-#include "i_disk_mem_usage_listener.h"
-#include "ibucketfreezelistener.h"
-#include "ibucketstatechangedhandler.h"
-#include "iclusterstatechangedhandler.h"
-#include "ifrozenbuckethandler.h"
-#include <vespa/searchcore/proton/bucketdb/bucketscaniterator.h>
-#include <vespa/searchcore/proton/bucketdb/i_bucket_create_listener.h>
-#include <set>
-
-namespace proton {
-
-class BlockableMaintenanceJobConfig;
-class IBucketStateChangedNotifier;
-class IClusterStateChangedNotifier;
-class IDiskMemUsageNotifier;
-class IBucketModifiedHandler;
-
-namespace bucketdb { class IBucketCreateNotifier; }
-
-/**
- * Class used to control the moving of buckets between the ready and
- * not ready sub databases based on the readiness of buckets according to the cluster state.
- */
-class BucketMoveJob : public BlockableMaintenanceJob,
-                      public IClusterStateChangedHandler,
-                      public IBucketFreezeListener,
-                      public bucketdb::IBucketCreateListener,
-                      public IBucketStateChangedHandler,
-                      public IDiskMemUsageListener
-{
-private:
-    using ScanPosition = bucketdb::ScanPosition;
-    using ScanIterator = bucketdb::ScanIterator;
-    using ScanPass = ScanIterator::Pass;
-    using ScanResult = std::pair<size_t, bool>;
-    std::shared_ptr<IBucketStateCalculator>   _calc;
-    IDocumentMoveHandler                     &_moveHandler;
-    IBucketModifiedHandler                   &_modifiedHandler;
-    const MaintenanceDocumentSubDB           &_ready;
-    const MaintenanceDocumentSubDB           &_notReady;
-    DocumentBucketMover                       _mover;
-    bool                                      _doneScan;
-    ScanPosition                              _scanPos;
-    ScanPass                                  _scanPass;
-    ScanPosition                              _endPos;
-    document::BucketSpace                    _bucketSpace;
-
-    using DelayedBucketSet = std::set<document::BucketId>;
-
-    // Delayed buckets that are no longer frozen or active that can be considered for moving.
-    DelayedBucketSet                   _delayedBuckets;
-    // Frozen buckets that cannot be moved at all.
-    DelayedBucketSet                   _delayedBucketsFrozen;
-    IFrozenBucketHandler              &_frozenBuckets;
-    bucketdb::IBucketCreateNotifier   &_bucketCreateNotifier;
-    DocumentBucketMover                _delayedMover;
-    IClusterStateChangedNotifier      &_clusterStateChangedNotifier;
-    IBucketStateChangedNotifier       &_bucketStateChangedNotifier;
-    IDiskMemUsageNotifier             &_diskMemUsageNotifier;
-
-    ScanResult
-    scanBuckets(size_t maxBucketsToScan,
-                IFrozenBucketHandler::ExclusiveBucketGuard::UP & bucketGuard);
-
-    void maybeCancelMover(DocumentBucketMover &mover);
-    void maybeDelayMover(DocumentBucketMover &mover, document::BucketId bucket);
-
-    bool
-    moveDocuments(DocumentBucketMover &mover,
-                  size_t maxDocsToMove,
-                  IFrozenBucketHandler::ExclusiveBucketGuard::UP & bucketGuard);
-
-    void
-    checkBucket(const document::BucketId &bucket,
-                ScanIterator &itr,
-                DocumentBucketMover &mover,
-                IFrozenBucketHandler::ExclusiveBucketGuard::UP & bucketGuard);
-
-    /**
-     * Signal that the given bucket should be de-activated.
-     * An active bucket is not considered for moving from ready to not ready sub database.
-     * A de-activated bucket can be considered for moving.
-     **/
-    void deactivateBucket(document::BucketId bucket);
-
-    /**
-     * Signal that the given bucket should be activated.
-     */
-    void activateBucket(document::BucketId bucket);
-
-public:
-    BucketMoveJob(const std::shared_ptr<IBucketStateCalculator> &calc,
-                  IDocumentMoveHandler &moveHandler,
-                  IBucketModifiedHandler &modifiedHandler,
-                  const MaintenanceDocumentSubDB &ready,
-                  const MaintenanceDocumentSubDB &notReady,
-                  IFrozenBucketHandler &frozenBuckets,
-                  bucketdb::IBucketCreateNotifier &bucketCreateNotifier,
-                  IClusterStateChangedNotifier &clusterStateChangedNotifier,
-                  IBucketStateChangedNotifier &bucketStateChangedNotifier,
-                  IDiskMemUsageNotifier &diskMemUsageNotifier,
-                  const BlockableMaintenanceJobConfig &blockableConfig,
-                  const vespalib::string &docTypeName,
-                  document::BucketSpace bucketSpace);
-
-    ~BucketMoveJob() override;
-
-    void changedCalculator();
-    bool scanAndMove(size_t maxBucketsToScan, size_t maxDocsToMove);
-
-    bool done() const {
-        // Ignores _delayedBucketsFrozen, since no work can be done there yet
-        return
-            _doneScan &&
-            _mover.bucketDone() &&
-            _delayedMover.bucketDone() &&
-            _delayedBuckets.empty();
-    }
-
-    // IMaintenanceJob API
-    bool run() override;
-
-    // IClusterStateChangedHandler API
-    void notifyClusterStateChanged(const std::shared_ptr<IBucketStateCalculator> &newCalc) override;
-
-    // IBucketFreezeListener API
-    void notifyThawedBucket(const document::BucketId &bucket) override;
-
-    // IBucketStateChangedHandler API
-    void notifyBucketStateChanged(const document::BucketId &bucketId,
-                                  storage::spi::BucketInfo::ActiveState newState) override;
-
-    void notifyDiskMemUsage(DiskMemUsageState state) override;
-
-    // bucketdb::IBucketCreateListener API
-    void notifyCreateBucket(const bucketdb::Guard & guard, const document::BucketId &bucket) override;
-};
-
-} // namespace proton
diff --git a/searchcore/src/vespa/searchcore/proton/server/lid_space_compaction_job.cpp b/searchcore/src/vespa/searchcore/proton/server/lid_space_compaction_job.cpp
deleted file mode 100644
index 095169b84ce..00000000000
--- a/searchcore/src/vespa/searchcore/proton/server/lid_space_compaction_job.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#include "lid_space_compaction_job.h"
-#include "i_document_scan_iterator.h"
-#include "ifrozenbuckethandler.h"
-#include "i_lid_space_compaction_handler.h"
-#include "i_operation_storer.h"
-#include <vespa/searchcore/proton/feedoperation/moveoperation.h>
-
-using search::DocumentMetaData;
-using search::LidUsageStats;
-
-namespace proton {
-
-bool
-LidSpaceCompactionJob::scanDocuments(const LidUsageStats &stats)
-{
-    if (_scanItr->valid()) {
-        DocumentMetaData document = getNextDocument(stats, _retryFrozenDocument);
-        _retryFrozenDocument = false;
-        if (document.valid()) {
-            IFrozenBucketHandler::ExclusiveBucketGuard::UP bucketGuard = _frozenHandler.acquireExclusiveBucket(document.bucketId);
-            if ( ! bucketGuard ) {
-                // the job is blocked until the bucket for this document is thawed
-                setBlocked(BlockedReason::FROZEN_BUCKET);
-                _retryFrozenDocument = true;
-                return true;
-            } else {
-                auto op = _handler->createMoveOperation(document, stats.getLowestFreeLid());
-                if ( ! op ) {
-                    return false;
-                }
-                vespalib::IDestructorCallback::SP context = getLimiter().beginOperation();
-                _opStorer.appendOperation(*op, context);
-                _handler->handleMove(*op, std::move(context));
-                if (isBlocked(BlockedReason::OUTSTANDING_OPS)) {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-
-LidSpaceCompactionJob::LidSpaceCompactionJob(const DocumentDBLidSpaceCompactionConfig &config,
-                                             std::shared_ptr<ILidSpaceCompactionHandler> handler,
-                                             IOperationStorer &opStorer,
-                                             IFrozenBucketHandler &frozenHandler,
-                                             IDiskMemUsageNotifier &diskMemUsageNotifier,
-                                             const BlockableMaintenanceJobConfig &blockableConfig,
-                                             IClusterStateChangedNotifier &clusterStateChangedNotifier,
-                                             bool nodeRetired)
-    : LidSpaceCompactionJobBase(config, std::move(handler), opStorer, diskMemUsageNotifier,
-                                blockableConfig, clusterStateChangedNotifier, nodeRetired),
-      _frozenHandler(frozenHandler),
-      _retryFrozenDocument(false)
-{
-}
-
-LidSpaceCompactionJob::~LidSpaceCompactionJob() = default;
-
-}
diff --git a/searchcore/src/vespa/searchcore/proton/server/lid_space_compaction_job.h b/searchcore/src/vespa/searchcore/proton/server/lid_space_compaction_job.h
deleted file mode 100644
index 4116a4cedf0..00000000000
--- a/searchcore/src/vespa/searchcore/proton/server/lid_space_compaction_job.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#pragma once
-
-#include "lid_space_compaction_job_base.h"
-
-namespace proton {
-
-class IFrozenBucketHandler;
-
-/**
- * Moves documents from higher lids to lower lids. It uses a 'frozen' bucket mechanism to ensure that it has exclusive access to the document.
- */
-class LidSpaceCompactionJob : public LidSpaceCompactionJobBase
-{
-private:
-    IFrozenBucketHandler         &_frozenHandler;
-    bool                          _retryFrozenDocument;
-
-    bool scanDocuments(const search::LidUsageStats &stats) override;
-
-public:
-    LidSpaceCompactionJob(const DocumentDBLidSpaceCompactionConfig &config,
-                          std::shared_ptr<ILidSpaceCompactionHandler> handler,
-                          IOperationStorer &opStorer,
-                          IFrozenBucketHandler &frozenHandler,
-                          IDiskMemUsageNotifier &diskMemUsageNotifier,
-                          const BlockableMaintenanceJobConfig &blockableConfig,
-                          IClusterStateChangedNotifier &clusterStateChangedNotifier,
-                          bool nodeRetired);
-    ~LidSpaceCompactionJob() override;
-};
-
-} // namespace proton
-
diff --git a/searchcore/src/vespa/searchcore/proton/server/maintenance_jobs_injector.cpp b/searchcore/src/vespa/searchcore/proton/server/maintenance_jobs_injector.cpp
index 7a5a42b5608..0dc3405d5ce 100644
--- a/searchcore/src/vespa/searchcore/proton/server/maintenance_jobs_injector.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/maintenance_jobs_injector.cpp
@@ -1,10 +1,8 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include "bucketmovejob.h"
 #include "bucketmovejobv2.h"
 #include "heart_beat_job.h"
 #include "job_tracked_maintenance_job.h"
-#include "lid_space_compaction_job.h"
 #include "lid_space_compaction_job_take2.h"
 #include "lid_space_compaction_handler.h"
 #include "maintenance_jobs_injector.h"
@@ -31,7 +29,6 @@ injectLidSpaceCompactionJobs(MaintenanceController &controller,
                              storage::spi::BucketExecutor & bucketExecutor,
                              ILidSpaceCompactionHandler::Vector lscHandlers,
                              IOperationStorer &opStorer,
-                             IFrozenBucketHandler &fbHandler,
                              IJobTracker::SP tracker,
                              IDiskMemUsageNotifier &diskMemUsageNotifier,
                              IClusterStateChangedNotifier &clusterStateChangedNotifier,
@@ -39,21 +36,10 @@ injectLidSpaceCompactionJobs(MaintenanceController &controller,
                              document::BucketSpace bucketSpace)
 {
     for (auto &lidHandler : lscHandlers) {
-        std::shared_ptr<IMaintenanceJob> job;
-        if (config.getLidSpaceCompactionConfig().useBucketExecutor()) {
-            job = lidspace::CompactionJob::create(config.getLidSpaceCompactionConfig(), controller.retainDB(),
-                                                  std::move(lidHandler), opStorer, controller.masterThread(),
-                                                  bucketExecutor, diskMemUsageNotifier,config.getBlockableJobConfig(),
-                                                  clusterStateChangedNotifier, (calc ? calc->nodeRetired() : false), bucketSpace);
-        } else {
-            job = std::make_shared<LidSpaceCompactionJob>(
-                    config.getLidSpaceCompactionConfig(),
-                    std::move(lidHandler), opStorer, fbHandler,
-                    diskMemUsageNotifier,
-                    config.getBlockableJobConfig(),
-                    clusterStateChangedNotifier,
-                    (calc ? calc->nodeRetired() : false));
-        }
+        auto job = lidspace::CompactionJob::create(config.getLidSpaceCompactionConfig(), controller.retainDB(),
+                                                   std::move(lidHandler), opStorer, controller.masterThread(),
+                                                   bucketExecutor, diskMemUsageNotifier,config.getBlockableJobConfig(),
+                                                   clusterStateChangedNotifier, (calc ? calc->nodeRetired() : false), bucketSpace);
         controller.registerJobInMasterThread(trackJob(tracker, std::move(job)));
     }
 }
@@ -61,7 +47,6 @@ injectLidSpaceCompactionJobs(MaintenanceController &controller,
 void
 injectBucketMoveJob(MaintenanceController &controller,
                     const DocumentDBMaintenanceConfig &config,
-                    IFrozenBucketHandler &fbHandler,
                     storage::spi::BucketExecutor & bucketExecutor,
                     bucketdb::IBucketCreateNotifier &bucketCreateNotifier,
                     const vespalib::string &docTypeName,
@@ -74,26 +59,10 @@ injectBucketMoveJob(MaintenanceController &controller,
                     DocumentDBJobTrackers &jobTrackers,
                     IDiskMemUsageNotifier &diskMemUsageNotifier)
 {
-    std::shared_ptr<IMaintenanceJob> bmj;
-    if (config.getBucketMoveConfig().useBucketExecutor()) {
-        bmj = BucketMoveJobV2::create(calc, controller.retainDB(), moveHandler, bucketModifiedHandler, controller.masterThread(),
-                                      bucketExecutor, controller.getReadySubDB(), controller.getNotReadySubDB(),
-                                      bucketCreateNotifier, clusterStateChangedNotifier, bucketStateChangedNotifier,
-                                      diskMemUsageNotifier, config.getBlockableJobConfig(), docTypeName, bucketSpace);
-    } else {
-        bmj = std::make_shared<BucketMoveJob>(calc,
-                                              moveHandler,
-                                              bucketModifiedHandler,
-                                              controller.getReadySubDB(),
-                                              controller.getNotReadySubDB(),
-                                              fbHandler,
-                                              bucketCreateNotifier,
-                                              clusterStateChangedNotifier,
-                                              bucketStateChangedNotifier,
-                                              diskMemUsageNotifier,
-                                              config.getBlockableJobConfig(),
-                                              docTypeName, bucketSpace);
-    }
+    auto bmj = BucketMoveJobV2::create(calc, controller.retainDB(), moveHandler, bucketModifiedHandler, controller.masterThread(),
+                                       bucketExecutor, controller.getReadySubDB(), controller.getNotReadySubDB(),
+                                       bucketCreateNotifier, clusterStateChangedNotifier, bucketStateChangedNotifier,
+                                       diskMemUsageNotifier, config.getBlockableJobConfig(), docTypeName, bucketSpace);
     controller.registerJobInMasterThread(trackJob(jobTrackers.getBucketMove(), std::move(bmj)));
 }
 
@@ -138,11 +107,11 @@ MaintenanceJobsInjector::injectJobs(MaintenanceController &controller,
         lidSpaceCompactionHandlers.push_back(std::make_shared<LidSpaceCompactionHandler>(controller.getRemSubDB(), docTypeName));
         lidSpaceCompactionHandlers.push_back(std::make_shared<LidSpaceCompactionHandler>(controller.getNotReadySubDB(), docTypeName));
         injectLidSpaceCompactionJobs(controller, config, bucketExecutor, std::move(lidSpaceCompactionHandlers),
-                                     opStorer, fbHandler, jobTrackers.getLidSpaceCompact(), diskMemUsageNotifier,
+                                     opStorer, jobTrackers.getLidSpaceCompact(), diskMemUsageNotifier,
                                      clusterStateChangedNotifier, calc, bucketSpace);
     }
 
-    injectBucketMoveJob(controller, config, fbHandler, bucketExecutor, bucketCreateNotifier, docTypeName, bucketSpace,
+    injectBucketMoveJob(controller, config, bucketExecutor, bucketCreateNotifier, docTypeName, bucketSpace,
                         moveHandler, bucketModifiedHandler, clusterStateChangedNotifier, bucketStateChangedNotifier,
                         calc, jobTrackers, diskMemUsageNotifier);