Allocate feature executors on a stash to get them close together in memory.

129 files changed, 460 insertions, 494 deletions

diff --git a/searchlib/src/tests/features/prod_features.cpp b/searchlib/src/tests/features/prod_features.cpp
index c414c2598e5..425279fbfe1 100644
--- a/searchlib/src/tests/features/prod_features.cpp
+++ b/searchlib/src/tests/features/prod_features.cpp
@@ -1211,10 +1211,11 @@ Test::testDotProduct()
         DotProductBlueprint bp;
         DummyDependencyHandler deps(bp);
         EXPECT_TRUE(bp.setup(ft.getIndexEnv(), params));
-        FeatureExecutor::LP exc = bp.createExecutor(ft.getQueryEnv());
+        vespalib::Stash stash;
+        FeatureExecutor &exc = bp.createExecutor(ft.getQueryEnv(), stash);
         // check that we have the optimized enum version
         dotproduct::wset::DotProductExecutor<dotproduct::wset::EnumVector, WeightedEnumContent> * myExc =
-            dynamic_cast<dotproduct::wset::DotProductExecutor<dotproduct::wset::EnumVector, WeightedEnumContent> *>(exc.get());
+            dynamic_cast<dotproduct::wset::DotProductExecutor<dotproduct::wset::EnumVector, WeightedEnumContent> *>(&exc);
         EXPECT_TRUE(myExc != nullptr);
         EXPECT_EQUAL(1u, deps.output.size());
     }
diff --git a/searchlib/src/tests/fef/featureoverride/featureoverride.cpp b/searchlib/src/tests/fef/featureoverride/featureoverride.cpp
index b0929f50fa9..e5484443bbe 100644
--- a/searchlib/src/tests/fef/featureoverride/featureoverride.cpp
+++ b/searchlib/src/tests/fef/featureoverride/featureoverride.cpp
@@ -16,16 +16,16 @@ using namespace search::fef::test;
 using namespace search::features;
 using search::feature_t;
 
-typedef FeatureExecutor::LP FESP;
 typedef Blueprint::SP       BPSP;
 
 struct Fixture
 {
     MatchDataLayout mdl;
-    std::vector<FeatureExecutor::LP> executors;
+    vespalib::Stash stash;
+    std::vector<FeatureExecutor *> executors;
     MatchData::UP md;
     Fixture() : mdl(), executors(), md() {}
-    Fixture &add(FeatureExecutor::LP &executor, size_t outCnt) {
+    Fixture &add(FeatureExecutor *executor, size_t outCnt) {
         executor->inputs_done();
         for (uint32_t outIdx = 0; outIdx < outCnt; ++outIdx) {
             executor->bindOutput(mdl.allocFeature());
@@ -44,19 +44,19 @@ struct Fixture
     feature_t resolveFeature(FeatureHandle handle) {
         return *md->resolveFeature(handle);
     }
-    FESP createValueExecutor() {
+    FeatureExecutor &createValueExecutor() {
         std::vector<feature_t> values;
         values.push_back(1.0);
         values.push_back(2.0);
         values.push_back(3.0);
-        return FESP(new ValueExecutor(values));
+        return stash.create<ValueExecutor>(values);
     }
 };
 
 TEST_F("test decorator - single override", Fixture)
 {
-    FESP fe = f.createValueExecutor();
-    fe = FESP(new FeatureOverrider(fe, 1, 50.0));
+    FeatureExecutor *fe = &f.createValueExecutor();
+    fe = &f.stash.template create<FeatureOverrider>(*fe, 1, 50.0);
     f.add(fe, 3).run();
     EXPECT_EQUAL(fe->outputs().size(), 3u);
 
@@ -67,9 +67,9 @@ TEST_F("test decorator - single override", Fixture)
 
 TEST_F("test decorator - multiple overrides", Fixture)
 {
-    FESP fe = f.createValueExecutor();
-    fe = FESP(new FeatureOverrider(fe, 0, 50.0));
-    fe = FESP(new FeatureOverrider(fe, 2, 100.0));
+    FeatureExecutor *fe = &f.createValueExecutor();
+    fe = &f.stash.template create<FeatureOverrider>(*fe, 0, 50.0);
+    fe = &f.stash.template create<FeatureOverrider>(*fe, 2, 100.0);
     f.add(fe, 3).run();
     EXPECT_EQUAL(fe->outputs().size(), 3u);
 
@@ -80,8 +80,8 @@ TEST_F("test decorator - multiple overrides", Fixture)
 
 TEST_F("test decorator - non-existing override", Fixture)
 {
-    FESP fe = f.createValueExecutor();
-    fe = FESP(new FeatureOverrider(fe, 1000, 50.0));
+    FeatureExecutor *fe = &f.createValueExecutor();
+    fe = &f.stash.template create<FeatureOverrider>(*fe, 1000, 50.0);
     f.add(fe, 3).run();
     EXPECT_EQUAL(fe->outputs().size(), 3u);
 
@@ -93,17 +93,17 @@ TEST_F("test decorator - non-existing override", Fixture)
 TEST_F("test decorator - transitive override", Fixture)
 {
     FeatureExecutor::SharedInputs inputs;
-    FESP fe = f.createValueExecutor();
-    fe = FESP(new FeatureOverrider(fe, 1, 50.0));
+    FeatureExecutor *fe = &f.createValueExecutor();
+    fe = &f.stash.template create<FeatureOverrider>(*fe, 1, 50.0);
     f.add(fe, 3);
     EXPECT_EQUAL(fe->outputs().size(), 3u);
 
-    FESP fe2 = FESP(new DoubleExecutor(3));
+    FeatureExecutor *fe2 = &f.stash.template create<DoubleExecutor>(3);
     fe2->bind_shared_inputs(inputs);
     fe2->addInput(fe->outputs()[0]);
     fe2->addInput(fe->outputs()[1]);
     fe2->addInput(fe->outputs()[2]);
-    fe2 = FESP(new FeatureOverrider(fe2, 2, 10.0));
+    fe2 = &f.stash.template create<FeatureOverrider>(*fe2, 2, 10.0);
     f.add(fe2, 3).run();
     EXPECT_EQUAL(fe2->outputs().size(), 3u);
 
diff --git a/searchlib/src/tests/fef/object_passing/object_passing_test.cpp b/searchlib/src/tests/fef/object_passing/object_passing_test.cpp
index 69c681d8f60..815c634c929 100644
--- a/searchlib/src/tests/fef/object_passing/object_passing_test.cpp
+++ b/searchlib/src/tests/fef/object_passing/object_passing_test.cpp
@@ -58,8 +58,8 @@ struct ProxyBlueprint : Blueprint {
         describeOutput("was_object", "whether input was object", FeatureType::number());
         return true;
     }
-    FeatureExecutor::LP createExecutor(const IQueryEnvironment &) const override {
-        return FeatureExecutor::LP(new ProxyExecutor());
+    FeatureExecutor &createExecutor(const IQueryEnvironment &, vespalib::Stash &stash) const override {
+        return stash.create<ProxyExecutor>();
     }
 };
 
diff --git a/searchlib/src/tests/fef/rank_program/rank_program_test.cpp b/searchlib/src/tests/fef/rank_program/rank_program_test.cpp
index baf665c58e8..4cf309cc072 100644
--- a/searchlib/src/tests/fef/rank_program/rank_program_test.cpp
+++ b/searchlib/src/tests/fef/rank_program/rank_program_test.cpp
@@ -31,8 +31,8 @@ struct ImpureValueBlueprint : Blueprint {
         describeOutput("out", "the impure value");
         return true;
     }
-    FeatureExecutor::LP createExecutor(const IQueryEnvironment &) const override {
-        return FeatureExecutor::LP(new ImpureValueExecutor(value));
+    FeatureExecutor &createExecutor(const IQueryEnvironment &, vespalib::Stash &stash) const override {
+        return stash.create<ImpureValueExecutor>(value);
     }
 };
 
diff --git a/searchlib/src/tests/fef/resolver/resolver_test.cpp b/searchlib/src/tests/fef/resolver/resolver_test.cpp
index 21c4334cd71..e83d02d2577 100644
--- a/searchlib/src/tests/fef/resolver/resolver_test.cpp
+++ b/searchlib/src/tests/fef/resolver/resolver_test.cpp
@@ -5,6 +5,7 @@ LOG_SETUP("resolver_test");
 #include <vespa/vespalib/testkit/testapp.h>
 #include <vespa/searchlib/fef/fef.h>
 #include <vespa/searchlib/fef/test/indexenvironment.h>
+#include <vespa/searchlib/features/valuefeature.h>
 
 namespace search {
 namespace fef {
@@ -23,8 +24,12 @@ public:
         describeOutput("baz", "baz");
         return true;
     }
-    virtual FeatureExecutor::LP createExecutor(const IQueryEnvironment &) const override {
-        return FeatureExecutor::LP(NULL);
+    virtual FeatureExecutor &createExecutor(const IQueryEnvironment &, vespalib::Stash &stash) const override {
+        std::vector<feature_t> values;
+        values.push_back(0.0);
+        values.push_back(0.0);
+        values.push_back(0.0);
+        return stash.create<features::ValueExecutor>(values);
     }
 };
 
@@ -43,8 +48,8 @@ public:
         describeOutput("out", "out");
         return true;
     }
-    virtual FeatureExecutor::LP createExecutor(const IQueryEnvironment &) const override {
-        return FeatureExecutor::LP(NULL);
+    virtual FeatureExecutor &createExecutor(const IQueryEnvironment &, vespalib::Stash &stash) const override {
+        return stash.create<features::SingleZeroValueExecutor>();
     }
 };
 
diff --git a/searchlib/src/tests/ranksetup/ranksetup_test.cpp b/searchlib/src/tests/ranksetup/ranksetup_test.cpp
index 158442a9458..22c6478aeb9 100644
--- a/searchlib/src/tests/ranksetup/ranksetup_test.cpp
+++ b/searchlib/src/tests/ranksetup/ranksetup_test.cpp
@@ -265,8 +265,9 @@ RankSetupTest::testValueBlueprint()
         EXPECT_EQUAL(deps.output[0], "0");
         EXPECT_EQUAL(deps.output[1], "1");
 
-        FeatureExecutor::LP fe = bp->createExecutor(_queryEnv);
-        ValueExecutor * vfe = static_cast<ValueExecutor *>(fe.get());
+        vespalib::Stash stash;
+        FeatureExecutor &fe = bp->createExecutor(_queryEnv, stash);
+        ValueExecutor * vfe = static_cast<ValueExecutor *>(&fe);
         EXPECT_EQUAL(vfe->getValues().size(), 2u);
         EXPECT_EQUAL(vfe->getValues()[0], 5.5f);
         EXPECT_EQUAL(vfe->getValues()[1], 10.5f);
@@ -417,8 +418,9 @@ RankSetupTest::testCfgValueBlueprint()
         EXPECT_EQUAL(deps.output[1], "1");
         EXPECT_EQUAL(deps.output[2], "2");
 
-        FeatureExecutor::LP fe = bp->createExecutor(_queryEnv);
-        ValueExecutor *vfe = static_cast<ValueExecutor *>(fe.get());
+        vespalib::Stash stash;
+        FeatureExecutor &fe = bp->createExecutor(_queryEnv, stash);
+        ValueExecutor *vfe = static_cast<ValueExecutor *>(&fe);
         EXPECT_EQUAL(vfe->getValues().size(), 3u);
         EXPECT_EQUAL(vfe->getValues()[0], 1.0f);
         EXPECT_EQUAL(vfe->getValues()[1], 2.0f);
diff --git a/searchlib/src/vespa/searchlib/features/agefeature.cpp b/searchlib/src/vespa/searchlib/features/agefeature.cpp
index 0b8c652b5c7..ba24621f30b 100644
--- a/searchlib/src/vespa/searchlib/features/agefeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/agefeature.cpp
@@ -67,12 +67,12 @@ AgeBlueprint::createInstance() const
     return search::fef::Blueprint::UP(new AgeBlueprint());
 }
 
-search::fef::FeatureExecutor::LP
-AgeBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+AgeBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     // Get docdate attribute vector
     const IAttributeVector * attribute = env.getAttributeContext().getAttribute(_attribute);
-    return search::fef::FeatureExecutor::LP(new AgeExecutor(attribute));
+    return stash.create<AgeExecutor>(attribute);
 }
 
 }
diff --git a/searchlib/src/vespa/searchlib/features/agefeature.h b/searchlib/src/vespa/searchlib/features/agefeature.h
index 3d3cee49908..8b729e5bf14 100644
--- a/searchlib/src/vespa/searchlib/features/agefeature.h
+++ b/searchlib/src/vespa/searchlib/features/agefeature.h
@@ -47,7 +47,7 @@ public:
     virtual search::fef::Blueprint::UP createInstance() const;
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
     // Inherit doc from Blueprint.
     virtual search::fef::ParameterDescriptions getDescriptions() const {
diff --git a/searchlib/src/vespa/searchlib/features/attributefeature.cpp b/searchlib/src/vespa/searchlib/features/attributefeature.cpp
index efd1244a59e..e83e25d6a6e 100644
--- a/searchlib/src/vespa/searchlib/features/attributefeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/attributefeature.cpp
@@ -331,35 +331,32 @@ AttributeBlueprint::createInstance() const
 
 #define CREATE_AND_RETURN_IF_SINGLE_NUMERIC(a, T) \
     if (dynamic_cast<const SingleValueNumericAttribute<T> *>(a) != NULL) { \
-        return FeatureExecutor::LP(new SingleAttributeExecutor<SingleValueNumericAttribute<T>>(*static_cast<const SingleValueNumericAttribute<T> *>(a))); \
+        return stash.create<SingleAttributeExecutor<SingleValueNumericAttribute<T>>>(*static_cast<const SingleValueNumericAttribute<T> *>(a)); \
     }
 
 namespace {
 
-search::fef::FeatureExecutor::LP
-createAttributeExecutor(const IAttributeVector *attribute, const vespalib::string &attrName, const vespalib::string &extraParam)
+search::fef::FeatureExecutor &
+createAttributeExecutor(const IAttributeVector *attribute, const vespalib::string &attrName, const vespalib::string &extraParam, vespalib::Stash &stash)
 {
     if (attribute == NULL) {
         LOG(warning, "The attribute vector '%s' was not found in the attribute manager, returning default values.",
                 attrName.c_str());
         std::vector<feature_t> values(4, 0.0f);
-        return FeatureExecutor::LP(new ValueExecutor(values));
+        return stash.create<ValueExecutor>(values);
     }
     if (attribute->getCollectionType() == CollectionType::WSET) {
         bool useKey = !extraParam.empty();
         if (useKey) {
             if (attribute->isStringType()) {
-                return FeatureExecutor::LP
-                    (new WeightedSetAttributeExecutor<WeightedConstCharContent, vespalib::stringref>(attribute, extraParam, useKey));
+                return stash.create<WeightedSetAttributeExecutor<WeightedConstCharContent, vespalib::stringref>>(attribute, extraParam, useKey);
             } else if (attribute->isIntegerType()) {
-                return FeatureExecutor::LP
-                    (new WeightedSetAttributeExecutor<WeightedIntegerContent, int64_t>(attribute, util::strToNum<int64_t>(extraParam), useKey));
+                return stash.create<WeightedSetAttributeExecutor<WeightedIntegerContent, int64_t>>(attribute, util::strToNum<int64_t>(extraParam), useKey);
             } else { // FLOAT
-                return FeatureExecutor::LP
-                    (new WeightedSetAttributeExecutor<WeightedFloatContent, double>(attribute, util::strToNum<double>(extraParam), useKey));
+                return stash.create<WeightedSetAttributeExecutor<WeightedFloatContent, double>>(attribute, util::strToNum<double>(extraParam), useKey);
             }
         } else {
-            return FeatureExecutor::LP(new CountOnlyAttributeExecutor(*attribute));
+            return stash.create<CountOnlyAttributeExecutor>(*attribute);
         }
     } else { // SINGLE or ARRAY
         if ((attribute->getCollectionType() == CollectionType::SINGLE) && (attribute->isIntegerType() || attribute->isFloatingPointType())) {
@@ -373,39 +370,40 @@ createAttributeExecutor(const IAttributeVector *attribute, const vespalib::strin
             if (!extraParam.empty()) {
                 idx = util::strToNum<uint32_t>(extraParam);
             } else if (attribute->getCollectionType() == CollectionType::ARRAY) {
-                return FeatureExecutor::LP(new CountOnlyAttributeExecutor(*attribute));
+                return stash.create<CountOnlyAttributeExecutor>(*attribute);
             }
             if (attribute->isStringType()) {
-                return FeatureExecutor::LP(new AttributeExecutor<ConstCharContent>(attribute, idx));
+                return stash.create<AttributeExecutor<ConstCharContent>>(attribute, idx);
             } else if (attribute->isIntegerType()) {
-                return FeatureExecutor::LP(new AttributeExecutor<IntegerContent>(attribute, idx));
+                return stash.create<AttributeExecutor<IntegerContent>>(attribute, idx);
             } else { // FLOAT
-                return FeatureExecutor::LP(new AttributeExecutor<FloatContent>(attribute, idx));
+                return stash.create<AttributeExecutor<FloatContent>>(attribute, idx);
             }
         }
     }
 }
 
-search::fef::FeatureExecutor::LP
+search::fef::FeatureExecutor &
 createTensorAttributeExecutor(const IAttributeVector *attribute, const vespalib::string &attrName,
-                              const ValueType &tensorType)
+                              const ValueType &tensorType,
+                              vespalib::Stash &stash)
 {
     if (attribute == NULL) {
         LOG(warning, "The attribute vector '%s' was not found in the attribute manager."
                 " Returning empty tensor.", attrName.c_str());
-        return ConstantTensorExecutor::createEmpty(tensorType);
+        return ConstantTensorExecutor::createEmpty(tensorType, stash);
     }
     if (attribute->getCollectionType() != search::attribute::CollectionType::SINGLE ||
             attribute->getBasicType() != search::attribute::BasicType::TENSOR) {
         LOG(warning, "The attribute vector '%s' is NOT of type tensor."
                 " Returning empty tensor.", attribute->getName().c_str());
-        return ConstantTensorExecutor::createEmpty(tensorType);
+        return ConstantTensorExecutor::createEmpty(tensorType, stash);
     }
     const TensorAttribute *tensorAttribute = dynamic_cast<const TensorAttribute *>(attribute);
     if (tensorAttribute == nullptr) {
         LOG(warning, "The attribute vector '%s' could not be converted to a tensor attribute."
                 " Returning empty tensor.", attribute->getName().c_str());
-        return ConstantTensorExecutor::createEmpty(tensorType);
+        return ConstantTensorExecutor::createEmpty(tensorType, stash);
     }
     if (tensorType != tensorAttribute->getConfig().tensorType()) {
         LOG(warning, "The tensor attribute '%s' has tensor type '%s',"
@@ -413,26 +411,26 @@ createTensorAttributeExecutor(const IAttributeVector *attribute, const vespalib:
                 tensorAttribute->getName().c_str(),
                 tensorAttribute->getConfig().tensorType().to_spec().c_str(),
                 tensorType.to_spec().c_str());
-        return ConstantTensorExecutor::createEmpty(tensorType);
+        return ConstantTensorExecutor::createEmpty(tensorType, stash);
     }
     if (tensorType.is_dense()) {
         const DenseTensorAttribute *denseTensorAttribute = dynamic_cast<const DenseTensorAttribute *>(tensorAttribute);
         assert(denseTensorAttribute != nullptr);
-        return FeatureExecutor::LP(new DenseTensorAttributeExecutor(denseTensorAttribute));
+        return stash.create<DenseTensorAttributeExecutor>(denseTensorAttribute);
     }
-    return FeatureExecutor::LP(new TensorAttributeExecutor(tensorAttribute));
+    return stash.create<TensorAttributeExecutor>(tensorAttribute);
 }
 
 }
 
-search::fef::FeatureExecutor::LP
-AttributeBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+AttributeBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     const IAttributeVector *attribute = env.getAttributeContext().getAttribute(_attrName);
     if (_tensorType.is_tensor()) {
-        return createTensorAttributeExecutor(attribute, _attrName, _tensorType);
+        return createTensorAttributeExecutor(attribute, _attrName, _tensorType, stash);
     } else {
-        return createAttributeExecutor(attribute, _attrName, _extra);
+        return createAttributeExecutor(attribute, _attrName, _extra, stash);
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/features/attributefeature.h b/searchlib/src/vespa/searchlib/features/attributefeature.h
index bff6600c45d..fdefea2aeee 100644
--- a/searchlib/src/vespa/searchlib/features/attributefeature.h
+++ b/searchlib/src/vespa/searchlib/features/attributefeature.h
@@ -36,7 +36,7 @@ public:
     virtual search::fef::Blueprint::UP createInstance() const;
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
     // Inherit doc from Blueprint.
     virtual search::fef::ParameterDescriptions getDescriptions() const {
diff --git a/searchlib/src/vespa/searchlib/features/attributematchfeature.cpp b/searchlib/src/vespa/searchlib/features/attributematchfeature.cpp
index bca39ef4b73..419322c9616 100644
--- a/searchlib/src/vespa/searchlib/features/attributematchfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/attributematchfeature.cpp
@@ -320,13 +320,25 @@ AttributeMatchBlueprint::setup(const IIndexEnvironment & env,
     return true;
 }
 
-FeatureExecutor::LP
-AttributeMatchBlueprint::createExecutor(const IQueryEnvironment & env) const
+FeatureExecutor &
+AttributeMatchBlueprint::createExecutor(const IQueryEnvironment & env, vespalib::Stash &stash) const
 {
     const IAttributeVector * attribute = env.getAttributeContext().getAttribute(_params.attrInfo->name());
     if (attribute == NULL) {
         LOG(error, "The attribute vector '%s' was not found in the attribute manager.", _params.attrInfo->name().c_str());
-        return FeatureExecutor::LP(NULL);
+        std::vector<feature_t> values;
+        values.push_back(0.0); // completeness
+        values.push_back(0.0); // queryCompleteness
+        values.push_back(0.0); // fieldCompleteness
+        values.push_back(0.0); // normalizedWeight
+        values.push_back(0.0); // normalizedWeightedWeight
+        values.push_back(0.0); // weight
+        values.push_back(0.0); // significance
+        values.push_back(0.0); // importance
+        values.push_back(0.0); // matches
+        values.push_back(0.0); // totalWeight
+        values.push_back(0.0); // averageWeight
+        return stash.create<ValueExecutor>(values);
     }
 
     AttributeMatchParams amp = _params;
@@ -334,14 +346,11 @@ AttributeMatchBlueprint::createExecutor(const IQueryEnvironment & env) const
     amp.weightedSet = attribute->getCollectionType() == attribute::CollectionType::WSET;
 
     if (attribute->isStringType()) {
-        return FeatureExecutor::LP
-            (new AttributeMatchExecutor<WeightedConstCharContent>(env, amp));
+        return stash.create<AttributeMatchExecutor<WeightedConstCharContent>>(env, amp);
     } else if (attribute->isIntegerType()) {
-        return FeatureExecutor::LP
-            (new AttributeMatchExecutor<WeightedIntegerContent>(env, amp));
+        return stash.create<AttributeMatchExecutor<WeightedIntegerContent>>(env, amp);
     } else { // FLOAT
-        return FeatureExecutor::LP
-            (new AttributeMatchExecutor<WeightedFloatContent>(env, amp));
+        return stash.create<AttributeMatchExecutor<WeightedFloatContent>>(env, amp);
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/features/attributematchfeature.h b/searchlib/src/vespa/searchlib/features/attributematchfeature.h
index 6a7b6f837d4..b6319a07e6a 100644
--- a/searchlib/src/vespa/searchlib/features/attributematchfeature.h
+++ b/searchlib/src/vespa/searchlib/features/attributematchfeature.h
@@ -115,7 +115,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/closenessfeature.cpp b/searchlib/src/vespa/searchlib/features/closenessfeature.cpp
index f6b289bfd16..a7cde6e0240 100644
--- a/searchlib/src/vespa/searchlib/features/closenessfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/closenessfeature.cpp
@@ -99,10 +99,10 @@ ClosenessBlueprint::createInstance() const
     return Blueprint::UP(new ClosenessBlueprint());
 }
 
-FeatureExecutor::LP
-ClosenessBlueprint::createExecutor(const IQueryEnvironment &) const
+FeatureExecutor &
+ClosenessBlueprint::createExecutor(const IQueryEnvironment &, vespalib::Stash &stash) const
 {
-    return FeatureExecutor::LP(new ClosenessExecutor(_maxDistance, _scaleDistance));
+    return stash.create<ClosenessExecutor>(_maxDistance, _scaleDistance);
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/features/closenessfeature.h b/searchlib/src/vespa/searchlib/features/closenessfeature.h
index fdd06ec1018..3def80c66fc 100644
--- a/searchlib/src/vespa/searchlib/features/closenessfeature.h
+++ b/searchlib/src/vespa/searchlib/features/closenessfeature.h
@@ -58,7 +58,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/constant_feature.cpp b/searchlib/src/vespa/searchlib/features/constant_feature.cpp
index e0237587470..014efdeb5bc 100644
--- a/searchlib/src/vespa/searchlib/features/constant_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/constant_feature.cpp
@@ -30,8 +30,8 @@ public:
     virtual void execute(fef::MatchData &data) override {
         *data.resolve_object_feature(outputs()[0]) = _value;
     }
-    static FeatureExecutor::LP create(const vespalib::eval::Value &value) {
-        return FeatureExecutor::LP(new ConstantFeatureExecutor(value));
+    static FeatureExecutor &create(const vespalib::eval::Value &value, vespalib::Stash &stash) {
+        return stash.create<ConstantFeatureExecutor>(value);
     }
 };
 
@@ -75,15 +75,15 @@ ConstantBlueprint::setup(const IIndexEnvironment &env,
     return (_value && !_value->type().is_error());
 }
 
-FeatureExecutor::LP
-ConstantBlueprint::createExecutor(const IQueryEnvironment &env) const
+FeatureExecutor &
+ConstantBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     (void) env;
     if (_value) {
-        return ConstantFeatureExecutor::create(_value->value());
+        return ConstantFeatureExecutor::create(_value->value(), stash);
     } else {
         // Note: Should not happen, setup() has already failed
-        return FeatureExecutor::LP(new SingleZeroValueExecutor());
+        return stash.create<SingleZeroValueExecutor>();
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/features/constant_feature.h b/searchlib/src/vespa/searchlib/features/constant_feature.h
index 3360b072fe3..c8cd6511799 100644
--- a/searchlib/src/vespa/searchlib/features/constant_feature.h
+++ b/searchlib/src/vespa/searchlib/features/constant_feature.h
@@ -40,7 +40,7 @@ public:
     virtual bool setup(const search::fef::IIndexEnvironment &env,
                        const search::fef::ParameterList &params) override;
 
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/constant_tensor_executor.h b/searchlib/src/vespa/searchlib/features/constant_tensor_executor.h
index 641f533980f..2d98b6025d4 100644
--- a/searchlib/src/vespa/searchlib/features/constant_tensor_executor.h
+++ b/searchlib/src/vespa/searchlib/features/constant_tensor_executor.h
@@ -28,16 +28,15 @@ public:
     virtual void execute(fef::MatchData &data) override {
         *data.resolve_object_feature(outputs()[0]) = *_tensor;
     }
-    static fef::FeatureExecutor::LP create(std::unique_ptr<vespalib::eval::Tensor> tensor) {
-        return FeatureExecutor::LP(new ConstantTensorExecutor
-                                   (std::make_unique<vespalib::eval::TensorValue>(std::move(tensor))));
+    static fef::FeatureExecutor &create(std::unique_ptr<vespalib::eval::Tensor> tensor, vespalib::Stash &stash) {
+        return stash.create<ConstantTensorExecutor>(std::make_unique<vespalib::eval::TensorValue>(std::move(tensor)));
     }
-    static fef::FeatureExecutor::LP createEmpty(const vespalib::eval::ValueType &valueType) {
+    static fef::FeatureExecutor &createEmpty(const vespalib::eval::ValueType &valueType, vespalib::Stash &stash) {
         return create(vespalib::tensor::DefaultTensorEngine::ref()
-                      .create(vespalib::eval::TensorSpec(valueType.to_spec())));
+                      .create(vespalib::eval::TensorSpec(valueType.to_spec())), stash);
     }
-    static fef::FeatureExecutor::LP createEmpty() {
-        return createEmpty(vespalib::eval::ValueType::double_type());
+    static fef::FeatureExecutor &createEmpty(vespalib::Stash &stash) {
+        return createEmpty(vespalib::eval::ValueType::double_type(), stash);
     }
 };
 
diff --git a/searchlib/src/vespa/searchlib/features/debug_attribute_wait.cpp b/searchlib/src/vespa/searchlib/features/debug_attribute_wait.cpp
index 23cea2275f3..0c54443ace7 100644
--- a/searchlib/src/vespa/searchlib/features/debug_attribute_wait.cpp
+++ b/searchlib/src/vespa/searchlib/features/debug_attribute_wait.cpp
@@ -97,12 +97,12 @@ DebugAttributeWaitBlueprint::setup(const IIndexEnvironment &env, const Parameter
     return true;
 }
 
-FeatureExecutor::LP
-DebugAttributeWaitBlueprint::createExecutor(const IQueryEnvironment &env) const
+FeatureExecutor &
+DebugAttributeWaitBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     // Get attribute vector
     const IAttributeVector * attribute = env.getAttributeContext().getAttribute(_attribute);
-    return FeatureExecutor::LP(new DebugAttributeWaitExecutor(env, attribute, _params));
+    return stash.create<DebugAttributeWaitExecutor>(env, attribute, _params);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/debug_attribute_wait.h b/searchlib/src/vespa/searchlib/features/debug_attribute_wait.h
index de0df9cee2d..7eef47be4bf 100644
--- a/searchlib/src/vespa/searchlib/features/debug_attribute_wait.h
+++ b/searchlib/src/vespa/searchlib/features/debug_attribute_wait.h
@@ -32,7 +32,7 @@ public:
         return fef::ParameterDescriptions().desc().attribute(fef::ParameterCollection::ANY).number();
     }
     bool setup(const fef::IIndexEnvironment &env, const fef::ParameterList &params) override;
-    fef::FeatureExecutor::LP createExecutor(const fef::IQueryEnvironment & env) const override;
+    fef::FeatureExecutor &createExecutor(const fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/debug_wait.cpp b/searchlib/src/vespa/searchlib/features/debug_wait.cpp
index f3aa00ec206..537677c6b12 100644
--- a/searchlib/src/vespa/searchlib/features/debug_wait.cpp
+++ b/searchlib/src/vespa/searchlib/features/debug_wait.cpp
@@ -80,10 +80,10 @@ DebugWaitBlueprint::setup(const IIndexEnvironment &env, const ParameterList &par
     return true;
 }
 
-FeatureExecutor::LP
-DebugWaitBlueprint::createExecutor(const IQueryEnvironment &env) const
+FeatureExecutor &
+DebugWaitBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    return FeatureExecutor::LP(new DebugWaitExecutor(env, _params));
+    return stash.create<DebugWaitExecutor>(env, _params);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/debug_wait.h b/searchlib/src/vespa/searchlib/features/debug_wait.h
index 73dd33d311c..dc479c8e6e5 100644
--- a/searchlib/src/vespa/searchlib/features/debug_wait.h
+++ b/searchlib/src/vespa/searchlib/features/debug_wait.h
@@ -32,7 +32,7 @@ public:
         return fef::ParameterDescriptions().desc().number().number();
     }
     bool setup(const fef::IIndexEnvironment &env, const fef::ParameterList &params) override;
-    fef::FeatureExecutor::LP createExecutor(const fef::IQueryEnvironment & env) const override;
+    fef::FeatureExecutor &createExecutor(const fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/distancefeature.cpp b/searchlib/src/vespa/searchlib/features/distancefeature.cpp
index 8dfa6403daa..f315c8f9102 100644
--- a/searchlib/src/vespa/searchlib/features/distancefeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/distancefeature.cpp
@@ -109,8 +109,8 @@ DistanceBlueprint::setup(const IIndexEnvironment & env,
     return true;
 }
 
-FeatureExecutor::LP
-DistanceBlueprint::createExecutor(const IQueryEnvironment & env) const
+FeatureExecutor &
+DistanceBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     const search::attribute::IAttributeVector * pos = NULL;
     const Location & location = env.getLocation();
@@ -138,7 +138,7 @@ DistanceBlueprint::createExecutor(const IQueryEnvironment & env) const
         }
     }
 
-    return FeatureExecutor::LP(new DistanceExecutor(location, pos));
+    return stash.create<DistanceExecutor>(location, pos);
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/features/distancefeature.h b/searchlib/src/vespa/searchlib/features/distancefeature.h
index 1a68069ef54..dd03eddfa9a 100644
--- a/searchlib/src/vespa/searchlib/features/distancefeature.h
+++ b/searchlib/src/vespa/searchlib/features/distancefeature.h
@@ -66,7 +66,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/distancetopathfeature.cpp b/searchlib/src/vespa/searchlib/features/distancetopathfeature.cpp
index b045bbd0168..f6d53ccbdc1 100644
--- a/searchlib/src/vespa/searchlib/features/distancetopathfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/distancetopathfeature.cpp
@@ -123,8 +123,8 @@ DistanceToPathBlueprint::setup(const search::fef::IIndexEnvironment & env,
     return true;
 }
 
-search::fef::FeatureExecutor::LP
-DistanceToPathBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+DistanceToPathBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     // Retrieve path from query using the name of this and "path" as property.
     std::vector<Vector2> path;
@@ -170,7 +170,7 @@ DistanceToPathBlueprint::createExecutor(const search::fef::IQueryEnvironment &en
     }
 
     // Create and return a compatible executor.
-    return search::fef::FeatureExecutor::LP(new DistanceToPathExecutor(path, pos));
+    return stash.create<DistanceToPathExecutor>(path, pos);
 }
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/distancetopathfeature.h b/searchlib/src/vespa/searchlib/features/distancetopathfeature.h
index c755ba7b3c1..457a10b4cd7 100644
--- a/searchlib/src/vespa/searchlib/features/distancetopathfeature.h
+++ b/searchlib/src/vespa/searchlib/features/distancetopathfeature.h
@@ -73,7 +73,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/dotproductfeature.cpp b/searchlib/src/vespa/searchlib/features/dotproductfeature.cpp
index 4035b0964af..49e3eb610ab 100644
--- a/searchlib/src/vespa/searchlib/features/dotproductfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/dotproductfeature.cpp
@@ -221,36 +221,36 @@ parseVectors(const Property & prop, std::vector<T> & values, std::vector<uint32_
 }
 
 template <typename A>
-FeatureExecutor::LP
-create(const IAttributeVector * attribute, const Property & prop)
+FeatureExecutor &
+create(const IAttributeVector * attribute, const Property & prop, vespalib::Stash &stash)
 {
     std::vector<typename A::BaseType> values;
     std::vector<uint32_t> indexes;
     parseVectors(prop, values, indexes);
     if (values.empty()) {
-        return FeatureExecutor::LP(new SingleZeroValueExecutor());
+        return stash.create<SingleZeroValueExecutor>();
     }
     const A & iattr = dynamic_cast<const A &>(*attribute);
     if (indexes.empty()) {
         try {
             const multivalue::Value<typename A::BaseType> * tmp;
             iattr.getRawValues(0, tmp);
-            return FeatureExecutor::LP(new dotproduct::array::DotProductExecutor<A>(&iattr, values));
+            return stash.create<dotproduct::array::DotProductExecutor<A>>(&iattr, values);
         } catch (const std::runtime_error & e) {
             (void) e;
-            return FeatureExecutor::LP(new dotproduct::array::DotProductByCopyExecutor<A>(&iattr, values));
+            return stash.create<dotproduct::array::DotProductByCopyExecutor<A>>(&iattr, values);
         }
     } else {
         try {
             const multivalue::Value<typename A::BaseType> * tmp;
             iattr.getRawValues(0, tmp);
-            return FeatureExecutor::LP(new dotproduct::array::SparseDotProductExecutor<A>(&iattr, values, indexes));
+            return stash.create<dotproduct::array::SparseDotProductExecutor<A>>(&iattr, values, indexes);
         } catch (const std::runtime_error & e) {
             (void) e;
-            return FeatureExecutor::LP(new dotproduct::array::SparseDotProductByCopyExecutor<A>(&iattr, values, indexes));
+            return stash.create<dotproduct::array::SparseDotProductByCopyExecutor<A>>(&iattr, values, indexes);
         }
     }
-    return FeatureExecutor::LP(new SingleZeroValueExecutor());
+    return stash.create<SingleZeroValueExecutor>();
 }
 
 template <typename T>
@@ -264,52 +264,52 @@ struct ArrayParam : public fef::Anything
 };
 
 template <typename A>
-FeatureExecutor::LP
-create(const IAttributeVector * attribute, const ArrayParam<typename A::BaseType> & arguments)
+FeatureExecutor &
+create(const IAttributeVector * attribute, const ArrayParam<typename A::BaseType> & arguments, vespalib::Stash &stash)
 {
     if (arguments.values.empty()) {
-        return FeatureExecutor::LP(new SingleZeroValueExecutor());
+        return stash.create<SingleZeroValueExecutor>();
     }
     const A & iattr = dynamic_cast<const A &>(*attribute);
     if (arguments.indexes.empty()) {
         try {
             const multivalue::Value<typename A::BaseType> * tmp;
             iattr.getRawValues(0, tmp);
-            return FeatureExecutor::LP(new dotproduct::array::DotProductExecutor<A>(&iattr, arguments.values));
+            return stash.create<dotproduct::array::DotProductExecutor<A>>(&iattr, arguments.values);
         } catch (const std::runtime_error & e) {
             (void) e;
-            return FeatureExecutor::LP(new dotproduct::array::DotProductByCopyExecutor<A>(&iattr, arguments.values));
+            return stash.create<dotproduct::array::DotProductByCopyExecutor<A>>(&iattr, arguments.values);
         }
     } else {
         try {
             const multivalue::Value<typename A::BaseType> * tmp;
             iattr.getRawValues(0, tmp);
-            return FeatureExecutor::LP(new dotproduct::array::SparseDotProductExecutor<A>(&iattr, arguments.values, arguments.indexes));
+            return stash.create<dotproduct::array::SparseDotProductExecutor<A>>(&iattr, arguments.values, arguments.indexes);
         } catch (const std::runtime_error & e) {
             (void) e;
-            return FeatureExecutor::LP(new dotproduct::array::SparseDotProductByCopyExecutor<A>(&iattr, arguments.values, arguments.indexes));
+            return stash.create<dotproduct::array::SparseDotProductByCopyExecutor<A>>(&iattr, arguments.values, arguments.indexes);
         }
     }
-    return FeatureExecutor::LP(new SingleZeroValueExecutor());
+    return stash.create<SingleZeroValueExecutor>();
 }
 
 //const char * BINARY = "binary";
 const char * OBJECT = "object";
 
 
-FeatureExecutor::LP
-createFromObject(const IAttributeVector * attribute, const fef::Anything & object)
+FeatureExecutor &
+createFromObject(const IAttributeVector * attribute, const fef::Anything & object, vespalib::Stash &stash)
 {
     if (attribute->getCollectionType() == attribute::CollectionType::ARRAY) {
         switch (attribute->getBasicType()) {
             case BasicType::INT32:
-                return create<IntegerAttributeTemplate<int32_t>>(attribute, dynamic_cast<const ArrayParam<int32_t> &>(object));
+                return create<IntegerAttributeTemplate<int32_t>>(attribute, dynamic_cast<const ArrayParam<int32_t> &>(object), stash);
             case BasicType::INT64:
-                return create<IntegerAttributeTemplate<int64_t>>(attribute, dynamic_cast<const ArrayParam<int64_t> &>(object));
+                return create<IntegerAttributeTemplate<int64_t>>(attribute, dynamic_cast<const ArrayParam<int64_t> &>(object), stash);
             case BasicType::FLOAT:
-                return create<FloatingPointAttributeTemplate<float>>(attribute, dynamic_cast<const ArrayParam<float> &>(object));
+                return create<FloatingPointAttributeTemplate<float>>(attribute, dynamic_cast<const ArrayParam<float> &>(object), stash);
             case BasicType::DOUBLE:
-                return create<FloatingPointAttributeTemplate<double>>(attribute, dynamic_cast<const ArrayParam<double> &>(object));
+                return create<FloatingPointAttributeTemplate<double>>(attribute, dynamic_cast<const ArrayParam<double> &>(object), stash);
             default:
                 break;
         }
@@ -318,56 +318,52 @@ createFromObject(const IAttributeVector * attribute, const fef::Anything & objec
     //       where the query vector is represented as an object instead of a string.
     LOG(warning, "The attribute vector '%s' is NOT of type array<int/long/float/double>"
             ", returning executor with default value.", attribute->getName().c_str());
-    return FeatureExecutor::LP(new SingleZeroValueExecutor());
+    return stash.create<SingleZeroValueExecutor>();
 }
 
-FeatureExecutor::LP
-createFromString(const IAttributeVector * attribute, const Property & prop)
+FeatureExecutor &
+createFromString(const IAttributeVector * attribute, const Property & prop, vespalib::Stash &stash)
 {
     if (attribute->getCollectionType() == attribute::CollectionType::WSET) {
         if (attribute->isStringType()) {
             if (attribute->hasEnum()) {
                 dotproduct::wset::EnumVector vector(attribute);
                 WeightedSetParser::parse(prop.get(), vector);
-                return FeatureExecutor::LP
-                    (new dotproduct::wset::DotProductExecutor<dotproduct::wset::EnumVector, WeightedEnumContent>(attribute, vector));
+                return stash.create<dotproduct::wset::DotProductExecutor<dotproduct::wset::EnumVector, WeightedEnumContent>>(attribute, vector);
             } else {
                 dotproduct::wset::StringVector vector;
                 WeightedSetParser::parse(prop.get(), vector);
-                return FeatureExecutor::LP
-                    (new dotproduct::wset::DotProductExecutor<dotproduct::wset::StringVector, WeightedConstCharContent>(attribute, vector));
+                return stash.create<dotproduct::wset::DotProductExecutor<dotproduct::wset::StringVector, WeightedConstCharContent>>(attribute, vector);
             }
         } else if (attribute->isIntegerType()) {
             if (attribute->hasEnum()) {
                 dotproduct::wset::EnumVector vector(attribute);
                 WeightedSetParser::parse(prop.get(), vector);
-                return FeatureExecutor::LP
-                    (new dotproduct::wset::DotProductExecutor<dotproduct::wset::EnumVector, WeightedEnumContent>(attribute, vector));
+                return stash.create<dotproduct::wset::DotProductExecutor<dotproduct::wset::EnumVector, WeightedEnumContent>>(attribute, vector);
                 
             } else {
                 dotproduct::wset::IntegerVector vector;
                 WeightedSetParser::parse(prop.get(), vector);
-                return FeatureExecutor::LP
-                    (new dotproduct::wset::DotProductExecutor<dotproduct::wset::IntegerVector, WeightedIntegerContent>(attribute, vector));
+                return stash.create<dotproduct::wset::DotProductExecutor<dotproduct::wset::IntegerVector, WeightedIntegerContent>>(attribute, vector);
             }
         }
     } else if (attribute->getCollectionType() == attribute::CollectionType::ARRAY) {
         switch (attribute->getBasicType()) {
             case BasicType::INT32:
-                return create<IntegerAttributeTemplate<int32_t>>(attribute, prop);
+                return create<IntegerAttributeTemplate<int32_t>>(attribute, prop, stash);
             case BasicType::INT64:
-                return create<IntegerAttributeTemplate<int64_t>>(attribute, prop);
+                return create<IntegerAttributeTemplate<int64_t>>(attribute, prop, stash);
             case BasicType::FLOAT:
-                return create<FloatingPointAttributeTemplate<float>>(attribute, prop);
+                return create<FloatingPointAttributeTemplate<float>>(attribute, prop, stash);
             case BasicType::DOUBLE:
-                return create<FloatingPointAttributeTemplate<double>>(attribute, prop);
+                return create<FloatingPointAttributeTemplate<double>>(attribute, prop, stash);
             default:
                 break;
         }
     }
     LOG(warning, "The attribute vector '%s' is not of type weighted set string/integer nor"
                  " array<int/long/float/double>, returning executor with default value.", attribute->getName().c_str());
-    return FeatureExecutor::LP(new SingleZeroValueExecutor());
+    return stash.create<SingleZeroValueExecutor>();
 }
 
 }
@@ -424,14 +420,14 @@ DotProductBlueprint::prepareSharedState(const IQueryEnvironment & env, IObjectSt
     }
 }
 
-FeatureExecutor::LP
-DotProductBlueprint::createExecutor(const IQueryEnvironment & env) const
+FeatureExecutor &
+DotProductBlueprint::createExecutor(const IQueryEnvironment & env, vespalib::Stash &stash) const
 {
     const IAttributeVector * attribute = env.getAttributeContext().getAttribute(getAttribute(env));
     if (attribute == NULL) {
         LOG(warning, "The attribute vector '%s' was not found in the attribute manager, returning executor with default value.",
             getAttribute(env).c_str());
-        return FeatureExecutor::LP(new SingleZeroValueExecutor());
+        return stash.create<SingleZeroValueExecutor>();
     }
     if ((attribute->getCollectionType() == attribute::CollectionType::WSET) &&
         attribute->hasEnum() &&
@@ -441,14 +437,14 @@ DotProductBlueprint::createExecutor(const IQueryEnvironment & env) const
     }
     const fef::Anything * argument = env.getObjectStore().get(getBaseName() + "." + _queryVector + "." + OBJECT);
     if (argument != NULL) {
-        return createFromObject(attribute, *argument);
+        return createFromObject(attribute, *argument, stash);
     } else {
         Property prop = env.getProperties().lookup(getBaseName(), _queryVector);
         if (prop.found() && !prop.get().empty()) {
-            return createFromString(attribute, prop);
+            return createFromString(attribute, prop, stash);
         }
     }
-    return FeatureExecutor::LP(new SingleZeroValueExecutor());
+    return stash.create<SingleZeroValueExecutor>();
 }
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/dotproductfeature.h b/searchlib/src/vespa/searchlib/features/dotproductfeature.h
index 9d61d8a50fc..6cc425026ba 100644
--- a/searchlib/src/vespa/searchlib/features/dotproductfeature.h
+++ b/searchlib/src/vespa/searchlib/features/dotproductfeature.h
@@ -207,7 +207,7 @@ public:
     virtual void prepareSharedState(const fef::IQueryEnvironment & queryEnv, fef::IObjectStore & objectStore) const;
 
     // Inherit doc from Blueprint.
-    virtual fef::FeatureExecutor::LP createExecutor(const fef::IQueryEnvironment & env) const override;
+    virtual fef::FeatureExecutor &createExecutor(const fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
 };
 
diff --git a/searchlib/src/vespa/searchlib/features/element_completeness_feature.cpp b/searchlib/src/vespa/searchlib/features/element_completeness_feature.cpp
index 9b5945432e1..6e4c63cded4 100644
--- a/searchlib/src/vespa/searchlib/features/element_completeness_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/element_completeness_feature.cpp
@@ -131,10 +131,10 @@ ElementCompletenessBlueprint::setup(const search::fef::IIndexEnvironment &env,
     return true;
 }
 
-search::fef::FeatureExecutor::LP
-ElementCompletenessBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+ElementCompletenessBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    return search::fef::FeatureExecutor::LP(new ElementCompletenessExecutor(env, _params));
+    return stash.create<ElementCompletenessExecutor>(env, _params);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/element_completeness_feature.h b/searchlib/src/vespa/searchlib/features/element_completeness_feature.h
index ca029a3e896..e5f255ddddb 100644
--- a/searchlib/src/vespa/searchlib/features/element_completeness_feature.h
+++ b/searchlib/src/vespa/searchlib/features/element_completeness_feature.h
@@ -118,7 +118,7 @@ public:
                        const search::fef::ParameterList &params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
     // for testing
     const ElementCompletenessParams &getParams() const { return _params; }
diff --git a/searchlib/src/vespa/searchlib/features/element_similarity_feature.cpp b/searchlib/src/vespa/searchlib/features/element_similarity_feature.cpp
index 8597184dcaf..af91c37a987 100644
--- a/searchlib/src/vespa/searchlib/features/element_similarity_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/element_similarity_feature.cpp
@@ -400,15 +400,15 @@ ElementSimilarityBlueprint::setup(const fef::IIndexEnvironment &env,
     return true;
 }
 
-fef::FeatureExecutor::LP
-ElementSimilarityBlueprint::createExecutor(const fef::IQueryEnvironment &env) const
+fef::FeatureExecutor &
+ElementSimilarityBlueprint::createExecutor(const fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     std::vector<OutputSpec> output_specs;
     for (const auto &output: _outputs) {
         output_specs.emplace_back(output->compile_token->get().get_function<5>(),
                                   output->aggregator_factory->create());
     }
-    return fef::FeatureExecutor::LP(new ElementSimilarityExecutor(VectorizedQueryTerms(env, _field_id), std::move(output_specs)));
+    return stash.create<ElementSimilarityExecutor>(VectorizedQueryTerms(env, _field_id), std::move(output_specs));
 }
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/element_similarity_feature.h b/searchlib/src/vespa/searchlib/features/element_similarity_feature.h
index e0e10f65e2b..16f36ab051d 100644
--- a/searchlib/src/vespa/searchlib/features/element_similarity_feature.h
+++ b/searchlib/src/vespa/searchlib/features/element_similarity_feature.h
@@ -34,7 +34,7 @@ public:
     }
     virtual bool setup(const search::fef::IIndexEnvironment &env,
                        const search::fef::ParameterList &params);
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/euclidean_distance_feature.cpp b/searchlib/src/vespa/searchlib/features/euclidean_distance_feature.cpp
index c77f47e3d08..6249683c740 100644
--- a/searchlib/src/vespa/searchlib/features/euclidean_distance_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/euclidean_distance_feature.cpp
@@ -84,37 +84,37 @@ EuclideanDistanceBlueprint::createInstance() const
 namespace {
 
 template <typename DataType> 
-FeatureExecutor::LP create(const IAttributeVector &attribute, const Property &queryVector)
+FeatureExecutor & create(const IAttributeVector &attribute, const Property &queryVector, vespalib::Stash &stash)
 {
     std::vector<DataType> v;
     ArrayParser::parse(queryVector.get(), v);
-    return FeatureExecutor::LP(new EuclideanDistanceExecutor<DataType>(attribute, std::move(v)));        
+    return stash.create<EuclideanDistanceExecutor<DataType>>(attribute, std::move(v));
 }
 
 }
 
-FeatureExecutor::LP
-EuclideanDistanceBlueprint::createExecutor(const IQueryEnvironment &env) const
+FeatureExecutor &
+EuclideanDistanceBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     const IAttributeVector * attribute = env.getAttributeContext().getAttribute(_attributeName);
     if (attribute == NULL) {
         LOG(warning, "The attribute vector '%s' was not found in the attribute manager, returning executor with default value.",
             _attributeName.c_str());
-        return FeatureExecutor::LP(new SingleZeroValueExecutor());
+        return stash.create<SingleZeroValueExecutor>();
     }
 
     Property queryVector = env.getProperties().lookup(getBaseName(), _queryVector);
 
     if (attribute->getCollectionType() == attribute::CollectionType::ARRAY) {
         if (attribute->isIntegerType()) {
-            return create<IAttributeVector::largeint_t>(*attribute, queryVector);
+            return create<IAttributeVector::largeint_t>(*attribute, queryVector, stash);
         } else if (attribute->isFloatingPointType()) {
-            return create<double>(*attribute, queryVector);
+            return create<double>(*attribute, queryVector, stash);
         }
     }
     LOG(warning, "The attribute vector '%s' is NOT of type array<int/long/float/double>"
             ", returning executor with default value.", attribute->getName().c_str());
-    return FeatureExecutor::LP(new SingleZeroValueExecutor());
+    return stash.create<SingleZeroValueExecutor>();
 
 }
 
diff --git a/searchlib/src/vespa/searchlib/features/euclidean_distance_feature.h b/searchlib/src/vespa/searchlib/features/euclidean_distance_feature.h
index 23df79621ee..421fd590e0a 100644
--- a/searchlib/src/vespa/searchlib/features/euclidean_distance_feature.h
+++ b/searchlib/src/vespa/searchlib/features/euclidean_distance_feature.h
@@ -66,7 +66,7 @@ public:
                        const fef::ParameterList &params) override;
 
     // Inherit doc from Blueprint.
-    virtual fef::FeatureExecutor::LP createExecutor(const fef::IQueryEnvironment &env) const override;
+    virtual fef::FeatureExecutor &createExecutor(const fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
 };
 
diff --git a/searchlib/src/vespa/searchlib/features/fieldinfofeature.cpp b/searchlib/src/vespa/searchlib/features/fieldinfofeature.cpp
index 539dc3b0343..81b2d903940 100644
--- a/searchlib/src/vespa/searchlib/features/fieldinfofeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/fieldinfofeature.cpp
@@ -190,14 +190,14 @@ FieldInfoBlueprint::setup(const fef::IIndexEnvironment &indexEnv,
     return false;
 }
 
-fef::FeatureExecutor::LP
-FieldInfoBlueprint::createExecutor(const fef::IQueryEnvironment &queryEnv) const
+fef::FeatureExecutor &
+FieldInfoBlueprint::createExecutor(const fef::IQueryEnvironment &queryEnv, vespalib::Stash &stash) const
 {
     if (_overview) {
         std::vector<feature_t> values;
         values.push_back(_indexcnt);
         values.push_back(_attrcnt);
-        return fef::FeatureExecutor::LP(new ValueExecutor(values));
+        return stash.create<ValueExecutor>(values);
     }
     uint32_t fieldHandle = util::getTermFieldHandle(queryEnv, 0, _fieldId);
     if (fieldHandle == fef::IllegalHandle) {
@@ -210,14 +210,12 @@ FieldInfoBlueprint::createExecutor(const fef::IQueryEnvironment &queryEnv) const
         values.push_back(fef::FieldPositionsIterator::UNKNOWN_LENGTH); // default first pos
         values.push_back(fef::FieldPositionsIterator::UNKNOWN_LENGTH); // default last pos
         values.push_back(0.0f); // number of hits
-        return fef::FeatureExecutor::LP(new ValueExecutor(values));
+        return stash.create<ValueExecutor>(values);
     }
     if (_type == 1.0) {  // index
-        return fef::FeatureExecutor::
-            LP(new IndexFieldInfoExecutor(_type, _isFilter, _fieldId, fieldHandle));
+        return stash.create<IndexFieldInfoExecutor>(_type, _isFilter, _fieldId, fieldHandle);
     } else if (_type == 2.0) {  // attribute
-        return fef::FeatureExecutor::LP(
-                new AttrFieldInfoExecutor(_type, fieldHandle));
+        return stash.create<AttrFieldInfoExecutor>(_type, fieldHandle);
     }
     std::vector<feature_t> values;
     values.push_back(_type);
@@ -228,7 +226,7 @@ FieldInfoBlueprint::createExecutor(const fef::IQueryEnvironment &queryEnv) const
     values.push_back(fef::FieldPositionsIterator::UNKNOWN_LENGTH); // default first pos
     values.push_back(fef::FieldPositionsIterator::UNKNOWN_LENGTH); // default last pos
     values.push_back(0.0f); // number of hits
-    return fef::FeatureExecutor::LP(new ValueExecutor(values));
+    return stash.create<ValueExecutor>(values);
 }
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/fieldinfofeature.h b/searchlib/src/vespa/searchlib/features/fieldinfofeature.h
index e35aaf840b1..b7f7c4f2944 100644
--- a/searchlib/src/vespa/searchlib/features/fieldinfofeature.h
+++ b/searchlib/src/vespa/searchlib/features/fieldinfofeature.h
@@ -62,7 +62,7 @@ public:
     }
     virtual bool setup(const search::fef::IIndexEnvironment & env,
                        const search::fef::ParameterList & params);
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &queryEnv) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &queryEnv, vespalib::Stash &stash) const override;
 };
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/fieldlengthfeature.cpp b/searchlib/src/vespa/searchlib/features/fieldlengthfeature.cpp
index fa356a9e012..4045f50b968 100644
--- a/searchlib/src/vespa/searchlib/features/fieldlengthfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/fieldlengthfeature.cpp
@@ -85,15 +85,15 @@ FieldLengthBlueprint::createInstance() const
     return Blueprint::UP(new FieldLengthBlueprint());
 }
 
-FeatureExecutor::LP
-FieldLengthBlueprint::createExecutor(const IQueryEnvironment &env) const
+FeatureExecutor &
+FieldLengthBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     if (_field == 0) {
         std::vector<feature_t> values;
         values.push_back(fef::FieldPositionsIterator::UNKNOWN_LENGTH);
-        return FeatureExecutor::LP(new ValueExecutor(values));
+        return stash.create<ValueExecutor>(values);
     }
-    return FeatureExecutor::LP(new FieldLengthExecutor(env, _field->id()));
+    return stash.create<FieldLengthExecutor>(env, _field->id());
 }
 
 }}
diff --git a/searchlib/src/vespa/searchlib/features/fieldlengthfeature.h b/searchlib/src/vespa/searchlib/features/fieldlengthfeature.h
index 1d94a39866e..73f30a315cd 100644
--- a/searchlib/src/vespa/searchlib/features/fieldlengthfeature.h
+++ b/searchlib/src/vespa/searchlib/features/fieldlengthfeature.h
@@ -49,7 +49,7 @@ public:
     virtual search::fef::Blueprint::UP createInstance() const;
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
     // Inherit doc from Blueprint.
     virtual search::fef::ParameterDescriptions getDescriptions() const {
diff --git a/searchlib/src/vespa/searchlib/features/fieldmatchfeature.cpp b/searchlib/src/vespa/searchlib/features/fieldmatchfeature.cpp
index cec68d0c367..f0f71e00b81 100644
--- a/searchlib/src/vespa/searchlib/features/fieldmatchfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/fieldmatchfeature.cpp
@@ -300,10 +300,10 @@ FieldMatchBlueprint::setup(const IIndexEnvironment & env,
     return true;
 }
 
-FeatureExecutor::LP
-FieldMatchBlueprint::createExecutor(const IQueryEnvironment & env) const
+FeatureExecutor &
+FieldMatchBlueprint::createExecutor(const IQueryEnvironment & env, vespalib::Stash &stash) const
 {
-    return FeatureExecutor::LP(new FieldMatchExecutor(env, *_field, _params));
+    return stash.create<FieldMatchExecutor>(env, *_field, _params);
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/features/fieldmatchfeature.h b/searchlib/src/vespa/searchlib/features/fieldmatchfeature.h
index b3f98373687..34fbf8e19b9 100644
--- a/searchlib/src/vespa/searchlib/features/fieldmatchfeature.h
+++ b/searchlib/src/vespa/searchlib/features/fieldmatchfeature.h
@@ -61,7 +61,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/fieldtermmatchfeature.cpp b/searchlib/src/vespa/searchlib/features/fieldtermmatchfeature.cpp
index 7ce785e0c78..9b8d6f19dee 100644
--- a/searchlib/src/vespa/searchlib/features/fieldtermmatchfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/fieldtermmatchfeature.cpp
@@ -120,10 +120,10 @@ FieldTermMatchBlueprint::createInstance() const
     return search::fef::Blueprint::UP(new FieldTermMatchBlueprint());
 }
 
-search::fef::FeatureExecutor::LP
-FieldTermMatchBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+FieldTermMatchBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    return search::fef::FeatureExecutor::LP(new FieldTermMatchExecutor(env, _fieldId, _termId));
+    return stash.create<FieldTermMatchExecutor>(env, _fieldId, _termId);
 }
 
 }}
diff --git a/searchlib/src/vespa/searchlib/features/fieldtermmatchfeature.h b/searchlib/src/vespa/searchlib/features/fieldtermmatchfeature.h
index 5e02810f92f..a594ceaa96f 100644
--- a/searchlib/src/vespa/searchlib/features/fieldtermmatchfeature.h
+++ b/searchlib/src/vespa/searchlib/features/fieldtermmatchfeature.h
@@ -47,7 +47,7 @@ public:
     virtual search::fef::Blueprint::UP createInstance() const;
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
     // Inherit doc from Blueprint.
     virtual search::fef::ParameterDescriptions getDescriptions() const {
diff --git a/searchlib/src/vespa/searchlib/features/firstphasefeature.cpp b/searchlib/src/vespa/searchlib/features/firstphasefeature.cpp
index e3c7f7f5332..3304d5c713f 100644
--- a/searchlib/src/vespa/searchlib/features/firstphasefeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/firstphasefeature.cpp
@@ -51,10 +51,10 @@ FirstPhaseBlueprint::setup(const IIndexEnvironment & env,
     return true;
 }
 
-FeatureExecutor::LP
-FirstPhaseBlueprint::createExecutor(const IQueryEnvironment &) const
+FeatureExecutor &
+FirstPhaseBlueprint::createExecutor(const IQueryEnvironment &, vespalib::Stash &stash) const
 {
-    return FeatureExecutor::LP(new FirstPhaseExecutor());
+    return stash.create<FirstPhaseExecutor>();
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/features/firstphasefeature.h b/searchlib/src/vespa/searchlib/features/firstphasefeature.h
index 3f90e52d83e..4a96064df0f 100644
--- a/searchlib/src/vespa/searchlib/features/firstphasefeature.h
+++ b/searchlib/src/vespa/searchlib/features/firstphasefeature.h
@@ -44,7 +44,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/flow_completeness_feature.cpp b/searchlib/src/vespa/searchlib/features/flow_completeness_feature.cpp
index b33e367f4f0..a764654f230 100644
--- a/searchlib/src/vespa/searchlib/features/flow_completeness_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/flow_completeness_feature.cpp
@@ -297,10 +297,10 @@ FlowCompletenessBlueprint::setup(const search::fef::IIndexEnvironment &env,
     return true;
 }
 
-search::fef::FeatureExecutor::LP
-FlowCompletenessBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+FlowCompletenessBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    return search::fef::FeatureExecutor::LP(new FlowCompletenessExecutor(env, _params));
+    return stash.create<FlowCompletenessExecutor>(env, _params);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/flow_completeness_feature.h b/searchlib/src/vespa/searchlib/features/flow_completeness_feature.h
index fa3efa9db33..f30cd4641d0 100644
--- a/searchlib/src/vespa/searchlib/features/flow_completeness_feature.h
+++ b/searchlib/src/vespa/searchlib/features/flow_completeness_feature.h
@@ -100,8 +100,7 @@ public:
                        const search::fef::ParameterList &params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP
-    createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/foreachfeature.cpp b/searchlib/src/vespa/searchlib/features/foreachfeature.cpp
index 4ee92e9177d..2b91d96d2df 100644
--- a/searchlib/src/vespa/searchlib/features/foreachfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/foreachfeature.cpp
@@ -4,6 +4,7 @@
 #include <vespa/log/log.h>
 LOG_SETUP(".features.foreachfeature");
 #include "foreachfeature.h"
+#include "valuefeature.h"
 #include "utils.h"
 
 #include <boost/algorithm/string/replace.hpp>
@@ -107,8 +108,8 @@ ForeachBlueprint::setExecutorCreator(CO condition)
         CO _condition;
     public:
         ExecutorCreator(CO cond) : _condition(cond) {}
-        virtual search::fef::FeatureExecutor::LP create(uint32_t numInputs) const {
-            return search::fef::FeatureExecutor::LP(new ForeachExecutor<CO, OP>(_condition,  numInputs));
+        virtual search::fef::FeatureExecutor &create(uint32_t numInputs, vespalib::Stash &stash) const {
+            return stash.create<ForeachExecutor<CO, OP>>(_condition,  numInputs);
         }
     };
     _executorCreator.reset(new ExecutorCreator(condition));
@@ -172,13 +173,13 @@ ForeachBlueprint::createInstance() const
     return Blueprint::UP(new ForeachBlueprint());
 }
 
-FeatureExecutor::LP
-ForeachBlueprint::createExecutor(const IQueryEnvironment &) const
+FeatureExecutor &
+ForeachBlueprint::createExecutor(const IQueryEnvironment &, vespalib::Stash &stash) const
 {
     if (_executorCreator.get() != NULL) {
-        return _executorCreator->create(_num_inputs);
+        return _executorCreator->create(_num_inputs, stash);
     }
-    return FeatureExecutor::LP(NULL);
+    return stash.create<SingleZeroValueExecutor>();
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/features/foreachfeature.h b/searchlib/src/vespa/searchlib/features/foreachfeature.h
index a7c19c8aadb..dc51252ebd5 100644
--- a/searchlib/src/vespa/searchlib/features/foreachfeature.h
+++ b/searchlib/src/vespa/searchlib/features/foreachfeature.h
@@ -138,7 +138,7 @@ private:
         ILLEGAL
     };
     struct ExecutorCreatorBase {
-        virtual search::fef::FeatureExecutor::LP create(uint32_t numInputs) const = 0;
+        virtual search::fef::FeatureExecutor &create(uint32_t numInputs, vespalib::Stash &stash) const = 0;
         virtual ~ExecutorCreatorBase() {}
     };
 
@@ -176,7 +176,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/freshnessfeature.cpp b/searchlib/src/vespa/searchlib/features/freshnessfeature.cpp
index cc6d1c24c50..b4dee0ce618 100644
--- a/searchlib/src/vespa/searchlib/features/freshnessfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/freshnessfeature.cpp
@@ -89,10 +89,10 @@ FreshnessBlueprint::createInstance() const
     return Blueprint::UP(new FreshnessBlueprint());
 }
 
-FeatureExecutor::LP
-FreshnessBlueprint::createExecutor(const IQueryEnvironment &) const
+FeatureExecutor &
+FreshnessBlueprint::createExecutor(const IQueryEnvironment &, vespalib::Stash &stash) const
 {
-    return FeatureExecutor::LP(new FreshnessExecutor(_maxAge, _scaleAge));
+    return stash.create<FreshnessExecutor>(_maxAge, _scaleAge);
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/features/freshnessfeature.h b/searchlib/src/vespa/searchlib/features/freshnessfeature.h
index 7f32bc0b9fd..07e97f0438e 100644
--- a/searchlib/src/vespa/searchlib/features/freshnessfeature.h
+++ b/searchlib/src/vespa/searchlib/features/freshnessfeature.h
@@ -58,7 +58,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/item_raw_score_feature.cpp b/searchlib/src/vespa/searchlib/features/item_raw_score_feature.cpp
index cf980940c82..12536441998 100644
--- a/searchlib/src/vespa/searchlib/features/item_raw_score_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/item_raw_score_feature.cpp
@@ -49,16 +49,16 @@ ItemRawScoreBlueprint::setup(const IIndexEnvironment &,
     return true;
 }
 
-FeatureExecutor::LP
-ItemRawScoreBlueprint::createExecutor(const IQueryEnvironment &queryEnv) const
+FeatureExecutor &
+ItemRawScoreBlueprint::createExecutor(const IQueryEnvironment &queryEnv, vespalib::Stash &stash) const
 {
     HandleVector handles = resolve(queryEnv, _label);
     if (handles.size() == 1) {
-        return FeatureExecutor::LP(new SimpleItemRawScoreExecutor(handles[0]));
+        return stash.create<SimpleItemRawScoreExecutor>(handles[0]);
     } else if (handles.size() == 0) {
-        return FeatureExecutor::LP(new SingleZeroValueExecutor());
+        return stash.create<SingleZeroValueExecutor>();
     } else {        
-        return FeatureExecutor::LP(new ItemRawScoreExecutor(handles));
+        return stash.create<ItemRawScoreExecutor>(handles);
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/features/item_raw_score_feature.h b/searchlib/src/vespa/searchlib/features/item_raw_score_feature.h
index 3871b025eca..f6fe34bf234 100644
--- a/searchlib/src/vespa/searchlib/features/item_raw_score_feature.h
+++ b/searchlib/src/vespa/searchlib/features/item_raw_score_feature.h
@@ -50,8 +50,7 @@ public:
     }
     virtual bool setup(const fef::IIndexEnvironment &env,
                        const fef::ParameterList &params);
-    virtual fef::FeatureExecutor::LP
-    createExecutor(const fef::IQueryEnvironment &env) const override;
+    virtual fef::FeatureExecutor &createExecutor(const fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
     static HandleVector resolve(const fef::IQueryEnvironment &env,
                                 const vespalib::string &label);
diff --git a/searchlib/src/vespa/searchlib/features/jarowinklerdistancefeature.cpp b/searchlib/src/vespa/searchlib/features/jarowinklerdistancefeature.cpp
index b2d80324bec..d063453d116 100644
--- a/searchlib/src/vespa/searchlib/features/jarowinklerdistancefeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/jarowinklerdistancefeature.cpp
@@ -175,10 +175,10 @@ JaroWinklerDistanceBlueprint::createInstance() const
     return search::fef::Blueprint::UP(new JaroWinklerDistanceBlueprint());
 }
 
-search::fef::FeatureExecutor::LP
-JaroWinklerDistanceBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+JaroWinklerDistanceBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    return search::fef::FeatureExecutor::LP(new JaroWinklerDistanceExecutor(env, _config));
+    return stash.create<JaroWinklerDistanceExecutor>(env, _config);
 }
 
 }}
diff --git a/searchlib/src/vespa/searchlib/features/jarowinklerdistancefeature.h b/searchlib/src/vespa/searchlib/features/jarowinklerdistancefeature.h
index 9a5d219569d..ebe6352d0cb 100644
--- a/searchlib/src/vespa/searchlib/features/jarowinklerdistancefeature.h
+++ b/searchlib/src/vespa/searchlib/features/jarowinklerdistancefeature.h
@@ -74,7 +74,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
 private:
     JaroWinklerDistanceConfig _config; // The config for this blueprint.
diff --git a/searchlib/src/vespa/searchlib/features/matchcountfeature.cpp b/searchlib/src/vespa/searchlib/features/matchcountfeature.cpp
index b9b84bb97c2..7ffb4db26c8 100644
--- a/searchlib/src/vespa/searchlib/features/matchcountfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/matchcountfeature.cpp
@@ -65,13 +65,13 @@ MatchCountBlueprint::createInstance() const
     return Blueprint::UP(new MatchCountBlueprint());
 }
 
-FeatureExecutor::LP
-MatchCountBlueprint::createExecutor(const IQueryEnvironment & queryEnv) const
+FeatureExecutor &
+MatchCountBlueprint::createExecutor(const IQueryEnvironment & queryEnv, vespalib::Stash &stash) const
 {
     if (_field == nullptr) {
-        return FeatureExecutor::LP(new ValueExecutor(std::vector<feature_t>(1, 0.0)));
+        return stash.create<ValueExecutor>(std::vector<feature_t>(1, 0.0));
     }
-    return FeatureExecutor::LP(new MatchCountExecutor(_field->id(), queryEnv));
+    return stash.create<MatchCountExecutor>(_field->id(), queryEnv);
 }
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/matchcountfeature.h b/searchlib/src/vespa/searchlib/features/matchcountfeature.h
index 2f831dcf9a3..721df39861c 100644
--- a/searchlib/src/vespa/searchlib/features/matchcountfeature.h
+++ b/searchlib/src/vespa/searchlib/features/matchcountfeature.h
@@ -48,7 +48,7 @@ public:
     bool setup(const fef::IIndexEnvironment & env,
                const fef::ParameterList & params) override;
 
-    fef::FeatureExecutor::LP createExecutor(const fef::IQueryEnvironment & env) const override;
+    fef::FeatureExecutor &createExecutor(const fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/matchesfeature.cpp b/searchlib/src/vespa/searchlib/features/matchesfeature.cpp
index 459fe4487af..890e2182aca 100644
--- a/searchlib/src/vespa/searchlib/features/matchesfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/matchesfeature.cpp
@@ -73,16 +73,16 @@ MatchesBlueprint::createInstance() const
     return Blueprint::UP(new MatchesBlueprint());
 }
 
-FeatureExecutor::LP
-MatchesBlueprint::createExecutor(const IQueryEnvironment & queryEnv) const
+FeatureExecutor &
+MatchesBlueprint::createExecutor(const IQueryEnvironment & queryEnv, vespalib::Stash &stash) const
 {
     if (_field == 0) {
-        return search::fef::FeatureExecutor::LP(new ValueExecutor(std::vector<feature_t>(1, 0.0)));
+        return stash.create<ValueExecutor>(std::vector<feature_t>(1, 0.0));
     }
     if (_termIdx != std::numeric_limits<uint32_t>::max()) {
-        return FeatureExecutor::LP(new MatchesExecutor(_field->id(), queryEnv, _termIdx, _termIdx + 1));
+        return stash.create<MatchesExecutor>(_field->id(), queryEnv, _termIdx, _termIdx + 1);
     } else {
-        return FeatureExecutor::LP(new MatchesExecutor(_field->id(), queryEnv, 0, queryEnv.getNumTerms()));
+        return stash.create<MatchesExecutor>(_field->id(), queryEnv, 0, queryEnv.getNumTerms());
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/features/matchesfeature.h b/searchlib/src/vespa/searchlib/features/matchesfeature.h
index 130980ecff2..cd75a5dc6dc 100644
--- a/searchlib/src/vespa/searchlib/features/matchesfeature.h
+++ b/searchlib/src/vespa/searchlib/features/matchesfeature.h
@@ -63,7 +63,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/matchfeature.cpp b/searchlib/src/vespa/searchlib/features/matchfeature.cpp
index e80d56a2edd..cd19218ac8d 100644
--- a/searchlib/src/vespa/searchlib/features/matchfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/matchfeature.cpp
@@ -95,11 +95,11 @@ MatchBlueprint::setup(const IIndexEnvironment & env,
     return true;
 }
 
-FeatureExecutor::LP
-MatchBlueprint::createExecutor(const IQueryEnvironment & env) const
+FeatureExecutor &
+MatchBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     (void) env;
-    return FeatureExecutor::LP(new MatchExecutor(_params));
+    return stash.create<MatchExecutor>(_params);
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/features/matchfeature.h b/searchlib/src/vespa/searchlib/features/matchfeature.h
index a3876a95e2b..d904e96f508 100644
--- a/searchlib/src/vespa/searchlib/features/matchfeature.h
+++ b/searchlib/src/vespa/searchlib/features/matchfeature.h
@@ -59,7 +59,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/native_dot_product_feature.cpp b/searchlib/src/vespa/searchlib/features/native_dot_product_feature.cpp
index d135ecfdc91..8150808683e 100644
--- a/searchlib/src/vespa/searchlib/features/native_dot_product_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/native_dot_product_feature.cpp
@@ -47,10 +47,10 @@ NativeDotProductBlueprint::setup(const IIndexEnvironment &,
     return true;
 }
 
-FeatureExecutor::LP
-NativeDotProductBlueprint::createExecutor(const IQueryEnvironment &queryEnv) const
+FeatureExecutor &
+NativeDotProductBlueprint::createExecutor(const IQueryEnvironment &queryEnv, vespalib::Stash &stash) const
 {
-    return FeatureExecutor::LP(new NativeDotProductExecutor(queryEnv, _field->id()));
+    return stash.create<NativeDotProductExecutor>(queryEnv, _field->id());
 }
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/native_dot_product_feature.h b/searchlib/src/vespa/searchlib/features/native_dot_product_feature.h
index 882b828cbda..6abcfe59c40 100644
--- a/searchlib/src/vespa/searchlib/features/native_dot_product_feature.h
+++ b/searchlib/src/vespa/searchlib/features/native_dot_product_feature.h
@@ -38,8 +38,7 @@ public:
     }
     virtual bool setup(const search::fef::IIndexEnvironment &env,
                        const search::fef::ParameterList &params);
-    virtual search::fef::FeatureExecutor::LP
-    createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/nativeattributematchfeature.cpp b/searchlib/src/vespa/searchlib/features/nativeattributematchfeature.cpp
index a3e68c2907d..7ef1d02b200 100644
--- a/searchlib/src/vespa/searchlib/features/nativeattributematchfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/nativeattributematchfeature.cpp
@@ -47,17 +47,18 @@ NativeAttributeMatchExecutor::preComputeSetup(const IQueryEnvironment & env,
     return precomputed;
 }
 
-FeatureExecutor::LP
+FeatureExecutor &
 NativeAttributeMatchExecutor::createExecutor(const IQueryEnvironment & env,
-                                             const NativeAttributeMatchParams & params)
+                                             const NativeAttributeMatchParams & params,
+                                             vespalib::Stash &stash)
 {
     Precomputed setup = preComputeSetup(env, params);
     if (setup.first.size() == 0) {
-        return LP(new ValueExecutor(std::vector<feature_t>(1, 0.0)));
+        return stash.create<ValueExecutor>(std::vector<feature_t>(1, 0.0));
     } else if (setup.first.size() == 1) {
-        return LP(new NativeAttributeMatchExecutorSingle(setup));
+        return stash.create<NativeAttributeMatchExecutorSingle>(setup);
     } else {
-        return LP(new NativeAttributeMatchExecutorMulti(setup));
+        return stash.create<NativeAttributeMatchExecutorMulti>(setup);
     }
 }
 
@@ -139,10 +140,10 @@ NativeAttributeMatchBlueprint::setup(const IIndexEnvironment & env,
     return true;
 }
 
-FeatureExecutor::LP
-NativeAttributeMatchBlueprint::createExecutor(const IQueryEnvironment & env) const
+FeatureExecutor &
+NativeAttributeMatchBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    return FeatureExecutor::LP(NativeAttributeMatchExecutor::createExecutor(env, _params));
+    return NativeAttributeMatchExecutor::createExecutor(env, _params, stash);
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/features/nativeattributematchfeature.h b/searchlib/src/vespa/searchlib/features/nativeattributematchfeature.h
index e2c7e0be3a4..dc65394fd7c 100644
--- a/searchlib/src/vespa/searchlib/features/nativeattributematchfeature.h
+++ b/searchlib/src/vespa/searchlib/features/nativeattributematchfeature.h
@@ -48,8 +48,9 @@ private:
                                         const NativeAttributeMatchParams & params);
 
 public:
-    static fef::FeatureExecutor::LP createExecutor(const fef::IQueryEnvironment & env,
-                                                           const NativeAttributeMatchParams & params);
+    static fef::FeatureExecutor &createExecutor(const fef::IQueryEnvironment & env,
+                                                const NativeAttributeMatchParams & params,
+                                                vespalib::Stash &stash);
 };
 
 class NativeAttributeMatchExecutorMulti : public NativeAttributeMatchExecutor
@@ -105,7 +106,7 @@ public:
                        const fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual fef::FeatureExecutor::LP createExecutor(const fef::IQueryEnvironment & env) const override;
+    virtual fef::FeatureExecutor &createExecutor(const fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
     /**
      * Obtains the parameters used by the executor.
diff --git a/searchlib/src/vespa/searchlib/features/nativefieldmatchfeature.cpp b/searchlib/src/vespa/searchlib/features/nativefieldmatchfeature.cpp
index e19d54e8d09..a07ea624d7f 100644
--- a/searchlib/src/vespa/searchlib/features/nativefieldmatchfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/nativefieldmatchfeature.cpp
@@ -164,14 +164,14 @@ NativeFieldMatchBlueprint::setup(const IIndexEnvironment & env,
     return true;
 }
 
-FeatureExecutor::LP
-NativeFieldMatchBlueprint::createExecutor(const IQueryEnvironment & env) const
+FeatureExecutor &
+NativeFieldMatchBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    std::unique_ptr<NativeFieldMatchExecutor> native(new NativeFieldMatchExecutor(env, _params));
-    if (native->empty()) {
-        return FeatureExecutor::LP(new ValueExecutor(std::vector<feature_t>(1, 0.0)));
+    NativeFieldMatchExecutor &native = stash.create<NativeFieldMatchExecutor>(env, _params);
+    if (native.empty()) {
+        return stash.create<ValueExecutor>(std::vector<feature_t>(1, 0.0));
     } else {
-        return FeatureExecutor::LP(native.release());
+        return native;
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/features/nativefieldmatchfeature.h b/searchlib/src/vespa/searchlib/features/nativefieldmatchfeature.h
index fd843335ad5..5773574cb4d 100644
--- a/searchlib/src/vespa/searchlib/features/nativefieldmatchfeature.h
+++ b/searchlib/src/vespa/searchlib/features/nativefieldmatchfeature.h
@@ -119,7 +119,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment & env, vespalib::Stash &stash) const override;
 
     /**
      * Obtains the parameters used by the executor.
diff --git a/searchlib/src/vespa/searchlib/features/nativeproximityfeature.cpp b/searchlib/src/vespa/searchlib/features/nativeproximityfeature.cpp
index 6d39aea8780..11a17ea6c17 100644
--- a/searchlib/src/vespa/searchlib/features/nativeproximityfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/nativeproximityfeature.cpp
@@ -201,14 +201,14 @@ NativeProximityBlueprint::setup(const IIndexEnvironment & env,
     return true;
 }
 
-FeatureExecutor::LP
-NativeProximityBlueprint::createExecutor(const IQueryEnvironment & env) const
+FeatureExecutor &
+NativeProximityBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    std::unique_ptr<NativeProximityExecutor> native(new NativeProximityExecutor(env, _params));
-    if (native->empty()) {
-        return FeatureExecutor::LP(new ValueExecutor(std::vector<feature_t>(1, 0.0)));
+    NativeProximityExecutor &native = stash.create<NativeProximityExecutor>(env, _params);
+    if (native.empty()) {
+        return stash.create<ValueExecutor>(std::vector<feature_t>(1, 0.0));
     } else {
-        return FeatureExecutor::LP(native.release());
+        return native;
     }
 
 }
diff --git a/searchlib/src/vespa/searchlib/features/nativeproximityfeature.h b/searchlib/src/vespa/searchlib/features/nativeproximityfeature.h
index 65242bdc847..b9fd66b24c9 100644
--- a/searchlib/src/vespa/searchlib/features/nativeproximityfeature.h
+++ b/searchlib/src/vespa/searchlib/features/nativeproximityfeature.h
@@ -105,7 +105,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
     /**
      * Obtains the parameters used by the executor.
diff --git a/searchlib/src/vespa/searchlib/features/nativerankfeature.cpp b/searchlib/src/vespa/searchlib/features/nativerankfeature.cpp
index b4d549df9cf..888d78380b9 100644
--- a/searchlib/src/vespa/searchlib/features/nativerankfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/nativerankfeature.cpp
@@ -151,13 +151,13 @@ NativeRankBlueprint::setup(const IIndexEnvironment & env,
     return true;
 }
 
-FeatureExecutor::LP
-NativeRankBlueprint::createExecutor(const IQueryEnvironment &) const
+FeatureExecutor &
+NativeRankBlueprint::createExecutor(const IQueryEnvironment &, vespalib::Stash &stash) const
 {
     if (_params.proximityWeight + _params.fieldMatchWeight + _params.attributeMatchWeight > 0) {
-        return FeatureExecutor::LP(new NativeRankExecutor(_params));
+        return stash.create<NativeRankExecutor>(_params);
     } else {
-        return FeatureExecutor::LP(new ValueExecutor(std::vector<feature_t>(1, 0.0)));
+        return stash.create<ValueExecutor>(std::vector<feature_t>(1, 0.0));
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/features/nativerankfeature.h b/searchlib/src/vespa/searchlib/features/nativerankfeature.h
index 9fbd1164a55..d590ddbbe5d 100644
--- a/searchlib/src/vespa/searchlib/features/nativerankfeature.h
+++ b/searchlib/src/vespa/searchlib/features/nativerankfeature.h
@@ -114,7 +114,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
     /**
      * Obtains the parameters used by the executor.
diff --git a/searchlib/src/vespa/searchlib/features/nowfeature.cpp b/searchlib/src/vespa/searchlib/features/nowfeature.cpp
index 28eb844c6b0..b1e72df9896 100644
--- a/searchlib/src/vespa/searchlib/features/nowfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/nowfeature.cpp
@@ -45,8 +45,8 @@ NowBlueprint::createInstance() const
     return search::fef::Blueprint::UP(new NowBlueprint());
 }
 
-search::fef::FeatureExecutor::LP
-NowBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+NowBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     int64_t timestamp;
     const fef::Property &prop = env.getProperties().lookup(fef::queryproperties::now::SystemTime::NAME);
@@ -57,7 +57,7 @@ NowBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
         now.SetNow();
         timestamp = (int64_t)now.Secs();
     }
-    return search::fef::FeatureExecutor::LP(new NowExecutor(timestamp));
+    return stash.create<NowExecutor>(timestamp);
 }
 
 }}
diff --git a/searchlib/src/vespa/searchlib/features/nowfeature.h b/searchlib/src/vespa/searchlib/features/nowfeature.h
index c46b63a82c3..2eeffb36557 100644
--- a/searchlib/src/vespa/searchlib/features/nowfeature.h
+++ b/searchlib/src/vespa/searchlib/features/nowfeature.h
@@ -53,7 +53,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 }}
diff --git a/searchlib/src/vespa/searchlib/features/proximityfeature.cpp b/searchlib/src/vespa/searchlib/features/proximityfeature.cpp
index 5fd590650fd..dddf47c4dde 100644
--- a/searchlib/src/vespa/searchlib/features/proximityfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/proximityfeature.cpp
@@ -140,10 +140,10 @@ ProximityBlueprint::createInstance() const
     return search::fef::Blueprint::UP(new ProximityBlueprint());
 }
 
-search::fef::FeatureExecutor::LP
-ProximityBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+ProximityBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    return search::fef::FeatureExecutor::LP(new ProximityExecutor(env, _config));
+    return stash.create<ProximityExecutor>(env, _config);
 }
 
 }}
diff --git a/searchlib/src/vespa/searchlib/features/proximityfeature.h b/searchlib/src/vespa/searchlib/features/proximityfeature.h
index 93edaa027d5..b65b2396834 100644
--- a/searchlib/src/vespa/searchlib/features/proximityfeature.h
+++ b/searchlib/src/vespa/searchlib/features/proximityfeature.h
@@ -72,7 +72,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
 private:
     ProximityConfig _config;
diff --git a/searchlib/src/vespa/searchlib/features/querycompletenessfeature.cpp b/searchlib/src/vespa/searchlib/features/querycompletenessfeature.cpp
index 8d944f970c1..ed6353449ae 100644
--- a/searchlib/src/vespa/searchlib/features/querycompletenessfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/querycompletenessfeature.cpp
@@ -103,10 +103,10 @@ QueryCompletenessBlueprint::createInstance() const
     return search::fef::Blueprint::UP(new QueryCompletenessBlueprint());
 }
 
-search::fef::FeatureExecutor::LP
-QueryCompletenessBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+QueryCompletenessBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    return search::fef::FeatureExecutor::LP(new QueryCompletenessExecutor(env, _config));
+    return stash.create<QueryCompletenessExecutor>(env, _config);
 }
 
 }}
diff --git a/searchlib/src/vespa/searchlib/features/querycompletenessfeature.h b/searchlib/src/vespa/searchlib/features/querycompletenessfeature.h
index 02c86269211..f3ed812f930 100644
--- a/searchlib/src/vespa/searchlib/features/querycompletenessfeature.h
+++ b/searchlib/src/vespa/searchlib/features/querycompletenessfeature.h
@@ -70,7 +70,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
 private:
     QueryCompletenessConfig _config;
diff --git a/searchlib/src/vespa/searchlib/features/queryfeature.cpp b/searchlib/src/vespa/searchlib/features/queryfeature.cpp
index cf45f8112b9..b449849f6df 100644
--- a/searchlib/src/vespa/searchlib/features/queryfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/queryfeature.cpp
@@ -111,10 +111,10 @@ QueryBlueprint::setup(const IIndexEnvironment &env,
 
 namespace {
 
-FeatureExecutor::LP
+FeatureExecutor &
 createTensorExecutor(const search::fef::IQueryEnvironment &env,
                      const vespalib::string &queryKey,
-                     const ValueType &valueType)
+                     const ValueType &valueType, vespalib::Stash &stash)
 {
     search::fef::Property prop = env.getProperties().lookup(queryKey);
     if (prop.found() && !prop.get().empty()) {
@@ -128,18 +128,18 @@ createTensorExecutor(const search::fef::IQueryEnvironment &env,
             vespalib::tensor::Tensor::UP mappedTensor = mapper.map(*tensor);
             tensor = std::move(mappedTensor);
         }
-        return ConstantTensorExecutor::create(std::move(tensor));
+        return ConstantTensorExecutor::create(std::move(tensor), stash);
     }
-    return ConstantTensorExecutor::createEmpty(valueType);
+    return ConstantTensorExecutor::createEmpty(valueType, stash);
 }
 
 }
 
-FeatureExecutor::LP
-QueryBlueprint::createExecutor(const IQueryEnvironment &env) const
+FeatureExecutor &
+QueryBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     if (_valueType.is_tensor()) {
-        return createTensorExecutor(env, _key, _valueType);
+        return createTensorExecutor(env, _key, _valueType, stash);
     } else {
         std::vector<feature_t> values;
         Property p = env.getProperties().lookup(_key);
@@ -151,7 +151,7 @@ QueryBlueprint::createExecutor(const IQueryEnvironment &env) const
         } else {
             values.push_back(_defaultValue);
         }
-        return FeatureExecutor::LP(new ValueExecutor(values));
+        return stash.create<ValueExecutor>(values);
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/features/queryfeature.h b/searchlib/src/vespa/searchlib/features/queryfeature.h
index e2b21e41ffb..df0c50c09c2 100644
--- a/searchlib/src/vespa/searchlib/features/queryfeature.h
+++ b/searchlib/src/vespa/searchlib/features/queryfeature.h
@@ -44,7 +44,7 @@ public:
                        const search::fef::ParameterList &params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/querytermcountfeature.cpp b/searchlib/src/vespa/searchlib/features/querytermcountfeature.cpp
index 7069b4208be..50cd4881817 100644
--- a/searchlib/src/vespa/searchlib/features/querytermcountfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/querytermcountfeature.cpp
@@ -45,12 +45,12 @@ QueryTermCountBlueprint::setup(const IIndexEnvironment &,
     return true;
 }
 
-FeatureExecutor::LP
-QueryTermCountBlueprint::createExecutor(const IQueryEnvironment & env) const
+FeatureExecutor &
+QueryTermCountBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     std::vector<feature_t> values;
     values.push_back(static_cast<feature_t>(env.getNumTerms()));
-    return FeatureExecutor::LP(new ValueExecutor(values));
+    return stash.create<ValueExecutor>(values);
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/features/querytermcountfeature.h b/searchlib/src/vespa/searchlib/features/querytermcountfeature.h
index 4c290fb5da1..f0c2ad1c2bb 100644
--- a/searchlib/src/vespa/searchlib/features/querytermcountfeature.h
+++ b/searchlib/src/vespa/searchlib/features/querytermcountfeature.h
@@ -39,7 +39,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment & env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/randomfeature.cpp b/searchlib/src/vespa/searchlib/features/randomfeature.cpp
index 2c470808a62..20fdb053136 100644
--- a/searchlib/src/vespa/searchlib/features/randomfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/randomfeature.cpp
@@ -66,8 +66,8 @@ RandomBlueprint::setup(const search::fef::IIndexEnvironment & env,
     return true;
 }
 
-search::fef::FeatureExecutor::LP
-RandomBlueprint::createExecutor(const search::fef::IQueryEnvironment & env) const
+search::fef::FeatureExecutor &
+RandomBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     uint64_t seed = _seed;
     if (seed == 0) {
@@ -79,7 +79,7 @@ RandomBlueprint::createExecutor(const search::fef::IQueryEnvironment & env) cons
     uint64_t matchSeed = util::strToNum<uint64_t>
         (env.getProperties().lookup(getName(), "match", "seed").get("1024")); // default seed
 
-    return search::fef::FeatureExecutor::LP(new RandomExecutor(seed, matchSeed));
+    return stash.create<RandomExecutor>(seed, matchSeed);
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/features/randomfeature.h b/searchlib/src/vespa/searchlib/features/randomfeature.h
index 5b34df7dd73..9a5f839bcdd 100644
--- a/searchlib/src/vespa/searchlib/features/randomfeature.h
+++ b/searchlib/src/vespa/searchlib/features/randomfeature.h
@@ -62,7 +62,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/rankingexpressionfeature.cpp b/searchlib/src/vespa/searchlib/features/rankingexpressionfeature.cpp
index 166da2865a1..d8bd9ea941f 100644
--- a/searchlib/src/vespa/searchlib/features/rankingexpressionfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/rankingexpressionfeature.cpp
@@ -213,14 +213,14 @@ RankingExpressionBlueprint::createInstance() const
     return fef::Blueprint::UP(new RankingExpressionBlueprint());
 }
 
-fef::FeatureExecutor::LP
-RankingExpressionBlueprint::createExecutor(const fef::IQueryEnvironment &) const
+fef::FeatureExecutor &
+RankingExpressionBlueprint::createExecutor(const fef::IQueryEnvironment &, vespalib::Stash &stash) const
 {
     if (_interpreted_function) {
-        return fef::FeatureExecutor::LP(new InterpretedRankingExpressionExecutor(*_interpreted_function));
+        return stash.create<InterpretedRankingExpressionExecutor>(*_interpreted_function);
     }
     assert(_compile_token.get() != nullptr); // will be nullptr for VERIFY_SETUP feature motivation
-    return fef::FeatureExecutor::LP(new CompiledRankingExpressionExecutor(_compile_token->get()));
+    return stash.create<CompiledRankingExpressionExecutor>(_compile_token->get());
 }
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/rankingexpressionfeature.h b/searchlib/src/vespa/searchlib/features/rankingexpressionfeature.h
index 0451795b1c8..4c22337c7d3 100644
--- a/searchlib/src/vespa/searchlib/features/rankingexpressionfeature.h
+++ b/searchlib/src/vespa/searchlib/features/rankingexpressionfeature.h
@@ -35,7 +35,7 @@ public:
     }
 
     bool setup(const fef::IIndexEnvironment & env, const fef::ParameterList & params) override;
-    fef::FeatureExecutor::LP createExecutor(const fef::IQueryEnvironment &env) const override;
+    fef::FeatureExecutor &createExecutor(const fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/raw_score_feature.cpp b/searchlib/src/vespa/searchlib/features/raw_score_feature.cpp
index c6689a45ecd..2604098a64b 100644
--- a/searchlib/src/vespa/searchlib/features/raw_score_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/raw_score_feature.cpp
@@ -47,10 +47,10 @@ RawScoreBlueprint::setup(const IIndexEnvironment &,
     return true;
 }
 
-FeatureExecutor::LP
-RawScoreBlueprint::createExecutor(const IQueryEnvironment &queryEnv) const
+FeatureExecutor &
+RawScoreBlueprint::createExecutor(const IQueryEnvironment &queryEnv, vespalib::Stash &stash) const
 {
-    return FeatureExecutor::LP(new RawScoreExecutor(queryEnv, _field->id()));
+    return stash.create<RawScoreExecutor>(queryEnv, _field->id());
 }
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/raw_score_feature.h b/searchlib/src/vespa/searchlib/features/raw_score_feature.h
index f8e9cedd8c3..778834e6ce0 100644
--- a/searchlib/src/vespa/searchlib/features/raw_score_feature.h
+++ b/searchlib/src/vespa/searchlib/features/raw_score_feature.h
@@ -35,8 +35,7 @@ public:
     }
     virtual bool setup(const search::fef::IIndexEnvironment &env,
                        const search::fef::ParameterList &params);
-    virtual search::fef::FeatureExecutor::LP
-    createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/reverseproximityfeature.cpp b/searchlib/src/vespa/searchlib/features/reverseproximityfeature.cpp
index 5a297a8da8a..27484c9bf4a 100644
--- a/searchlib/src/vespa/searchlib/features/reverseproximityfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/reverseproximityfeature.cpp
@@ -127,10 +127,10 @@ ReverseProximityBlueprint::createInstance() const
     return search::fef::Blueprint::UP(new ReverseProximityBlueprint());
 }
 
-search::fef::FeatureExecutor::LP
-ReverseProximityBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+ReverseProximityBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    return search::fef::FeatureExecutor::LP(new ReverseProximityExecutor(env, _config));
+    return stash.create<ReverseProximityExecutor>(env, _config);
 }
 
 }}
diff --git a/searchlib/src/vespa/searchlib/features/reverseproximityfeature.h b/searchlib/src/vespa/searchlib/features/reverseproximityfeature.h
index f9738edd8ee..a3b86604e97 100644
--- a/searchlib/src/vespa/searchlib/features/reverseproximityfeature.h
+++ b/searchlib/src/vespa/searchlib/features/reverseproximityfeature.h
@@ -68,7 +68,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
 private:
     ReverseProximityConfig _config;
diff --git a/searchlib/src/vespa/searchlib/features/subqueries_feature.cpp b/searchlib/src/vespa/searchlib/features/subqueries_feature.cpp
index f6736f2cac9..6b28c862f31 100644
--- a/searchlib/src/vespa/searchlib/features/subqueries_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/subqueries_feature.cpp
@@ -49,9 +49,9 @@ bool SubqueriesBlueprint::setup(const IIndexEnvironment &,
     return true;
 }
 
-FeatureExecutor::LP
-SubqueriesBlueprint::createExecutor(const IQueryEnvironment &queryEnv) const {
-    return FeatureExecutor::LP(new SubqueriesExecutor(queryEnv, _field->id()));
+FeatureExecutor &
+SubqueriesBlueprint::createExecutor(const IQueryEnvironment &queryEnv, vespalib::Stash &stash) const {
+    return stash.create<SubqueriesExecutor>(queryEnv, _field->id());
 }
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/subqueries_feature.h b/searchlib/src/vespa/searchlib/features/subqueries_feature.h
index 63003b457e5..35eaf26a5f4 100644
--- a/searchlib/src/vespa/searchlib/features/subqueries_feature.h
+++ b/searchlib/src/vespa/searchlib/features/subqueries_feature.h
@@ -34,8 +34,7 @@ public:
     }
     virtual bool setup(const search::fef::IIndexEnvironment &env,
                        const search::fef::ParameterList &params);
-    virtual search::fef::FeatureExecutor::LP
-    createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/tensor_from_labels_feature.cpp b/searchlib/src/vespa/searchlib/features/tensor_from_labels_feature.cpp
index da4cc7a204c..e39607e4ae6 100644
--- a/searchlib/src/vespa/searchlib/features/tensor_from_labels_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/tensor_from_labels_feature.cpp
@@ -53,22 +53,22 @@ TensorFromLabelsBlueprint::setup(const search::fef::IIndexEnvironment &env,
 
 namespace {
 
-FeatureExecutor::LP
+FeatureExecutor &
 createAttributeExecutor(const search::fef::IQueryEnvironment &env,
                         const vespalib::string &attrName,
-                        const vespalib::string &dimension)
+                        const vespalib::string &dimension, vespalib::Stash &stash)
 {
     const IAttributeVector *attribute = env.getAttributeContext().getAttribute(attrName);
     if (attribute == NULL) {
         LOG(warning, "The attribute vector '%s' was not found in the attribute manager."
                 " Returning empty tensor.", attrName.c_str());
-        return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{dimension}}));
+        return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{dimension}}), stash);
     }
     if (attribute->getCollectionType() != search::attribute::CollectionType::ARRAY ||
             attribute->isFloatingPointType()) {
         LOG(warning, "The attribute vector '%s' is NOT of type array of string or integer."
                 " Returning empty tensor.", attrName.c_str());
-        return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{dimension}}));
+        return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{dimension}}), stash);
     }
     // Note that for array attribute vectors the default weight is 1.0 for all values.
     // This means we can get the attribute content as weighted content and build
@@ -76,19 +76,17 @@ createAttributeExecutor(const search::fef::IQueryEnvironment &env,
     if (attribute->isIntegerType()) {
         // Using WeightedStringContent ensures that the integer values are converted
         // to strings while extracting them from the attribute.
-        return FeatureExecutor::LP
-                (new TensorFromAttributeExecutor<WeightedStringContent>(attribute, dimension));
+        return stash.create<TensorFromAttributeExecutor<WeightedStringContent>>(attribute, dimension);
     }
     // When the underlying attribute is of type string we can reference these values
     // using WeightedConstCharContent.
-    return FeatureExecutor::LP
-            (new TensorFromAttributeExecutor<WeightedConstCharContent>(attribute, dimension));
+    return stash.create<TensorFromAttributeExecutor<WeightedConstCharContent>>(attribute, dimension);
 }
 
-FeatureExecutor::LP
+FeatureExecutor &
 createQueryExecutor(const search::fef::IQueryEnvironment &env,
                     const vespalib::string &queryKey,
-                    const vespalib::string &dimension)
+                    const vespalib::string &dimension, vespalib::Stash &stash)
 {
     search::fef::Property prop = env.getProperties().lookup(queryKey);
     if (prop.found() && !prop.get().empty()) {
@@ -100,22 +98,22 @@ createQueryExecutor(const search::fef::IQueryEnvironment &env,
             tensorBuilder.add_label(dimensionEnum, elem);
             tensorBuilder.add_cell(1.0);
         }
-        return ConstantTensorExecutor::create(tensorBuilder.build());
+        return ConstantTensorExecutor::create(tensorBuilder.build(), stash);
     }
-    return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{dimension}}));
+    return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{dimension}}), stash);
 }
 
 }
 
-FeatureExecutor::LP
-TensorFromLabelsBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+FeatureExecutor &
+TensorFromLabelsBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     if (_sourceType == ATTRIBUTE_SOURCE) {
-        return createAttributeExecutor(env, _sourceParam, _dimension);
+        return createAttributeExecutor(env, _sourceParam, _dimension, stash);
     } else if (_sourceType == QUERY_SOURCE) {
-        return createQueryExecutor(env, _sourceParam, _dimension);
+        return createQueryExecutor(env, _sourceParam, _dimension, stash);
     }
-    return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{_dimension}}));
+    return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{_dimension}}), stash);
 }
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/tensor_from_labels_feature.h b/searchlib/src/vespa/searchlib/features/tensor_from_labels_feature.h
index 3da8d07b063..c7e6afa5118 100644
--- a/searchlib/src/vespa/searchlib/features/tensor_from_labels_feature.h
+++ b/searchlib/src/vespa/searchlib/features/tensor_from_labels_feature.h
@@ -28,8 +28,7 @@ public:
     }
     virtual bool setup(const search::fef::IIndexEnvironment &env,
                        const search::fef::ParameterList &params) override;
-    virtual search::fef::FeatureExecutor::LP
-    createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/tensor_from_weighted_set_feature.cpp b/searchlib/src/vespa/searchlib/features/tensor_from_weighted_set_feature.cpp
index d90113e34ea..16db93af7e0 100644
--- a/searchlib/src/vespa/searchlib/features/tensor_from_weighted_set_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/tensor_from_weighted_set_feature.cpp
@@ -71,39 +71,38 @@ TensorFromWeightedSetBlueprint::setup(const search::fef::IIndexEnvironment &env,
 
 namespace {
 
-FeatureExecutor::LP
+FeatureExecutor &
 createAttributeExecutor(const search::fef::IQueryEnvironment &env,
                         const vespalib::string &attrName,
-                        const vespalib::string &dimension)
+                        const vespalib::string &dimension,
+                        vespalib::Stash &stash)
 {
     const IAttributeVector *attribute = env.getAttributeContext().getAttribute(attrName);
     if (attribute == NULL) {
         LOG(warning, "The attribute vector '%s' was not found in the attribute manager."
                 " Returning empty tensor.", attrName.c_str());
-        return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{dimension}}));
+        return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{dimension}}), stash);
     }
     if (attribute->getCollectionType() != search::attribute::CollectionType::WSET ||
             attribute->isFloatingPointType()) {
         LOG(warning, "The attribute vector '%s' is NOT of type weighted set of string or integer."
                 " Returning empty tensor.", attrName.c_str());
-        return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{dimension}}));
+        return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{dimension}}), stash);
     }
     if (attribute->isIntegerType()) {
         // Using WeightedStringContent ensures that the integer values are converted
         // to strings while extracting them from the attribute.
-        return FeatureExecutor::LP
-                (new TensorFromAttributeExecutor<WeightedStringContent>(attribute, dimension));
+        return stash.create<TensorFromAttributeExecutor<WeightedStringContent>>(attribute, dimension);
     }
     // When the underlying attribute is of type string we can reference these values
     // using WeightedConstCharContent.
-    return FeatureExecutor::LP
-            (new TensorFromAttributeExecutor<WeightedConstCharContent>(attribute, dimension));
+    return stash.create<TensorFromAttributeExecutor<WeightedConstCharContent>>(attribute, dimension);
 }
 
-FeatureExecutor::LP
+FeatureExecutor &
 createQueryExecutor(const search::fef::IQueryEnvironment &env,
                     const vespalib::string &queryKey,
-                    const vespalib::string &dimension)
+                    const vespalib::string &dimension, vespalib::Stash &stash)
 {
     search::fef::Property prop = env.getProperties().lookup(queryKey);
     if (prop.found() && !prop.get().empty()) {
@@ -115,22 +114,22 @@ createQueryExecutor(const search::fef::IQueryEnvironment &env,
             tensorBuilder.add_label(dimensionEnum, elem.value());
             tensorBuilder.add_cell(elem.weight());
         }
-        return ConstantTensorExecutor::create(tensorBuilder.build());
+        return ConstantTensorExecutor::create(tensorBuilder.build(), stash);
     }
-    return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{dimension}}));
+    return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{dimension}}), stash);
 }
 
 }
 
-FeatureExecutor::LP
-TensorFromWeightedSetBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+FeatureExecutor &
+TensorFromWeightedSetBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
     if (_sourceType == ATTRIBUTE_SOURCE) {
-        return createAttributeExecutor(env, _sourceParam, _dimension);
+        return createAttributeExecutor(env, _sourceParam, _dimension, stash);
     } else if (_sourceType == QUERY_SOURCE) {
-        return createQueryExecutor(env, _sourceParam, _dimension);
+        return createQueryExecutor(env, _sourceParam, _dimension, stash);
     }
-    return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{_dimension}}));
+    return ConstantTensorExecutor::createEmpty(ValueType::tensor_type({{_dimension}}), stash);
 }
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/tensor_from_weighted_set_feature.h b/searchlib/src/vespa/searchlib/features/tensor_from_weighted_set_feature.h
index f38b811fa36..c4d55703644 100644
--- a/searchlib/src/vespa/searchlib/features/tensor_from_weighted_set_feature.h
+++ b/searchlib/src/vespa/searchlib/features/tensor_from_weighted_set_feature.h
@@ -25,8 +25,7 @@ public:
     }
     virtual bool setup(const search::fef::IIndexEnvironment &env,
                        const search::fef::ParameterList &params) override;
-    virtual search::fef::FeatureExecutor::LP
-    createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/term_field_md_feature.cpp b/searchlib/src/vespa/searchlib/features/term_field_md_feature.cpp
index 1e242f8b4f3..b7bda86df5d 100644
--- a/searchlib/src/vespa/searchlib/features/term_field_md_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/term_field_md_feature.cpp
@@ -104,10 +104,10 @@ TermFieldMdBlueprint::setup(const IIndexEnvironment & env,
     return true;
 }
 
-FeatureExecutor::LP
-TermFieldMdBlueprint::createExecutor(const IQueryEnvironment & env) const
+FeatureExecutor &
+TermFieldMdBlueprint::createExecutor(const IQueryEnvironment & env, vespalib::Stash &stash) const
 {
-    return FeatureExecutor::LP(new TermFieldMdExecutor(env, _field->id()));
+    return stash.create<TermFieldMdExecutor>(env, _field->id());
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/features/term_field_md_feature.h b/searchlib/src/vespa/searchlib/features/term_field_md_feature.h
index 97b62d95ab0..dc1105243f1 100644
--- a/searchlib/src/vespa/searchlib/features/term_field_md_feature.h
+++ b/searchlib/src/vespa/searchlib/features/term_field_md_feature.h
@@ -51,7 +51,7 @@ public:
                        const fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual fef::FeatureExecutor::LP createExecutor(const fef::IQueryEnvironment & env) const override;
+    virtual fef::FeatureExecutor &createExecutor(const fef::IQueryEnvironment & env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/termdistancefeature.cpp b/searchlib/src/vespa/searchlib/features/termdistancefeature.cpp
index 8bfc191cc98..344ae74fa08 100644
--- a/searchlib/src/vespa/searchlib/features/termdistancefeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/termdistancefeature.cpp
@@ -78,12 +78,12 @@ TermDistanceBlueprint::setup(const IIndexEnvironment &,
     return true;
 }
 
-FeatureExecutor::LP
-TermDistanceBlueprint::createExecutor(const IQueryEnvironment & env) const
+FeatureExecutor &
+TermDistanceBlueprint::createExecutor(const IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    std::unique_ptr<TermDistanceExecutor> tde(new TermDistanceExecutor(env, _params));
-    if (tde->valid()) {
-        return FeatureExecutor::LP(tde.release());
+    TermDistanceExecutor &tde(stash.create<TermDistanceExecutor>(env, _params));
+    if (tde.valid()) {
+        return tde;
     } else {
         TermDistanceCalculator::Result r;
         std::vector<feature_t> values(4);
@@ -91,7 +91,7 @@ TermDistanceBlueprint::createExecutor(const IQueryEnvironment & env) const
         values[1] = r.forwardTermPos;
         values[2] = r.reverseDist;
         values[3] = r.reverseTermPos;
-        return FeatureExecutor::LP(new ValueExecutor(values));
+        return stash.create<ValueExecutor>(values);
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/features/termdistancefeature.h b/searchlib/src/vespa/searchlib/features/termdistancefeature.h
index f587c4a4680..daea4e92aaf 100644
--- a/searchlib/src/vespa/searchlib/features/termdistancefeature.h
+++ b/searchlib/src/vespa/searchlib/features/termdistancefeature.h
@@ -65,7 +65,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/features/termeditdistancefeature.cpp b/searchlib/src/vespa/searchlib/features/termeditdistancefeature.cpp
index 82b2e0b5058..1afdf794f93 100644
--- a/searchlib/src/vespa/searchlib/features/termeditdistancefeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/termeditdistancefeature.cpp
@@ -225,10 +225,10 @@ TermEditDistanceBlueprint::createInstance() const
     return search::fef::Blueprint::UP(new TermEditDistanceBlueprint());
 }
 
-search::fef::FeatureExecutor::LP
-TermEditDistanceBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+TermEditDistanceBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    return search::fef::FeatureExecutor::LP(new TermEditDistanceExecutor(env, _config));
+    return stash.create<TermEditDistanceExecutor>(env, _config);
 }
 
 }}
diff --git a/searchlib/src/vespa/searchlib/features/termeditdistancefeature.h b/searchlib/src/vespa/searchlib/features/termeditdistancefeature.h
index 7f46be3e4a8..e707d9b5130 100644
--- a/searchlib/src/vespa/searchlib/features/termeditdistancefeature.h
+++ b/searchlib/src/vespa/searchlib/features/termeditdistancefeature.h
@@ -119,7 +119,7 @@ public:
     virtual search::fef::Blueprint::UP createInstance() const;
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
     // Inherit doc from Blueprint.
     virtual search::fef::ParameterDescriptions getDescriptions() const {
diff --git a/searchlib/src/vespa/searchlib/features/termfeature.cpp b/searchlib/src/vespa/searchlib/features/termfeature.cpp
index 61cd3347845..3ead598f557 100644
--- a/searchlib/src/vespa/searchlib/features/termfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/termfeature.cpp
@@ -82,10 +82,10 @@ TermBlueprint::createInstance() const
     return search::fef::Blueprint::UP(new TermBlueprint());
 }
 
-search::fef::FeatureExecutor::LP
-TermBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+TermBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    return search::fef::FeatureExecutor::LP(new TermExecutor(env, _termId));
+    return stash.create<TermExecutor>(env, _termId);
 }
 
 }}
diff --git a/searchlib/src/vespa/searchlib/features/termfeature.h b/searchlib/src/vespa/searchlib/features/termfeature.h
index 6862ecd3b85..686579f2a89 100644
--- a/searchlib/src/vespa/searchlib/features/termfeature.h
+++ b/searchlib/src/vespa/searchlib/features/termfeature.h
@@ -58,7 +58,7 @@ public:
                        const search::fef::ParameterList & params);
 
     // Inherit doc from Blueprint.
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 
 private:
     uint32_t _termId;
diff --git a/searchlib/src/vespa/searchlib/features/terminfofeature.cpp b/searchlib/src/vespa/searchlib/features/terminfofeature.cpp
index 5ca385b0440..07b2904bf2a 100644
--- a/searchlib/src/vespa/searchlib/features/terminfofeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/terminfofeature.cpp
@@ -39,8 +39,8 @@ TermInfoBlueprint::setup(const search::fef::IIndexEnvironment &,
     return true;
 }
 
-search::fef::FeatureExecutor::LP
-TermInfoBlueprint::createExecutor(const search::fef::IQueryEnvironment &queryEnv) const
+search::fef::FeatureExecutor &
+TermInfoBlueprint::createExecutor(const search::fef::IQueryEnvironment &queryEnv, vespalib::Stash &stash) const
 {
     feature_t queryIdx = -1.0;
     if (queryEnv.getNumTerms() > _termIdx) {
@@ -48,7 +48,7 @@ TermInfoBlueprint::createExecutor(const search::fef::IQueryEnvironment &queryEnv
     }
     std::vector<feature_t> values;
     values.push_back(queryIdx);
-    return search::fef::FeatureExecutor::LP(new ValueExecutor(values));
+    return stash.create<ValueExecutor>(values);
 }
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/terminfofeature.h b/searchlib/src/vespa/searchlib/features/terminfofeature.h
index 1a67097bff7..975721d6797 100644
--- a/searchlib/src/vespa/searchlib/features/terminfofeature.h
+++ b/searchlib/src/vespa/searchlib/features/terminfofeature.h
@@ -25,7 +25,7 @@ public:
     }
     virtual bool setup(const search::fef::IIndexEnvironment & env,
                        const search::fef::ParameterList & params);
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment &queryEnv) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &queryEnv, vespalib::Stash &stash) const override;
 };
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/features/text_similarity_feature.cpp b/searchlib/src/vespa/searchlib/features/text_similarity_feature.cpp
index 794e67560b4..fe5d64d4434 100644
--- a/searchlib/src/vespa/searchlib/features/text_similarity_feature.cpp
+++ b/searchlib/src/vespa/searchlib/features/text_similarity_feature.cpp
@@ -208,10 +208,10 @@ TextSimilarityBlueprint::setup(const search::fef::IIndexEnvironment &env,
     return true;
 }
 
-search::fef::FeatureExecutor::LP
-TextSimilarityBlueprint::createExecutor(const search::fef::IQueryEnvironment &env) const
+search::fef::FeatureExecutor &
+TextSimilarityBlueprint::createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const
 {
-    return search::fef::FeatureExecutor::LP(new TextSimilarityExecutor(env, _field_id));
+    return stash.create<TextSimilarityExecutor>(env, _field_id);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/text_similarity_feature.h b/searchlib/src/vespa/searchlib/features/text_similarity_feature.h
index e9d1b0d885b..f26bf27089d 100644
--- a/searchlib/src/vespa/searchlib/features/text_similarity_feature.h
+++ b/searchlib/src/vespa/searchlib/features/text_similarity_feature.h
@@ -65,7 +65,7 @@ public:
     }
     virtual bool setup(const search::fef::IIndexEnvironment &env,
                        const search::fef::ParameterList &params);
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & env) const override;
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &env, vespalib::Stash &stash) const override;
 };
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/features/valuefeature.cpp b/searchlib/src/vespa/searchlib/features/valuefeature.cpp
index 1a1a202744b..9728c6f5634 100644
--- a/searchlib/src/vespa/searchlib/features/valuefeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/valuefeature.cpp
@@ -61,5 +61,13 @@ ValueBlueprint::setup(const search::fef::IIndexEnvironment &,
     return true;
 }
 
+search::fef::FeatureExecutor &
+ValueBlueprint::createExecutor(const search::fef::IQueryEnvironment &queryEnv, vespalib::Stash &stash) const
+{
+    (void) queryEnv;
+    return stash.create<ValueExecutor>(_values);
+}
+
+
 } // namespace features
 } // namespace search
diff --git a/searchlib/src/vespa/searchlib/features/valuefeature.h b/searchlib/src/vespa/searchlib/features/valuefeature.h
index aa09cce63bc..fbffd5dcb8e 100644
--- a/searchlib/src/vespa/searchlib/features/valuefeature.h
+++ b/searchlib/src/vespa/searchlib/features/valuefeature.h
@@ -48,10 +48,7 @@ public:
     }
     virtual bool setup(const search::fef::IIndexEnvironment & env,
                        const search::fef::ParameterList & params);
-    virtual search::fef::FeatureExecutor::LP createExecutor(const search::fef::IQueryEnvironment & queryEnv) const override {
-        (void) queryEnv;
-        return search::fef::FeatureExecutor::LP(new ValueExecutor(_values));
-    }
+    virtual search::fef::FeatureExecutor &createExecutor(const search::fef::IQueryEnvironment &queryEnv, vespalib::Stash &stash) const override;
 };
 
 } // namespace features
diff --git a/searchlib/src/vespa/searchlib/fef/CMakeLists.txt b/searchlib/src/vespa/searchlib/fef/CMakeLists.txt
index 0004779ed91..98f254f298e 100644
--- a/searchlib/src/vespa/searchlib/fef/CMakeLists.txt
+++ b/searchlib/src/vespa/searchlib/fef/CMakeLists.txt
@@ -31,7 +31,6 @@ vespa_add_library(searchlib_fef OBJECT
     ranksetup.cpp
     simpletermdata.cpp
     simpletermfielddata.cpp
-    sumexecutor.cpp
     symmetrictable.cpp
     table.cpp
     tablemanager.cpp
diff --git a/searchlib/src/vespa/searchlib/fef/blueprint.h b/searchlib/src/vespa/searchlib/fef/blueprint.h
index 9b7a7c541a2..82b25bbfdbc 100644
--- a/searchlib/src/vespa/searchlib/fef/blueprint.h
+++ b/searchlib/src/vespa/searchlib/fef/blueprint.h
@@ -12,6 +12,8 @@
 #include "parameterdescriptions.h"
 #include "feature_type.h"
 
+namespace vespalib { class Stash; }
+
 namespace search {
 namespace fef {
 
@@ -236,10 +238,12 @@ public:
      * initialize a feature executor for this blueprint may be
      * signaled by returning a shared pointer to 0.
      *
-     * @return feature executor wrapped in a shared pointer
+     * @return feature executor allocated in stash.
      * @param queryEnv query environment
+     * @param stash    heterogenous object store
      **/
-    virtual FeatureExecutor::LP createExecutor(const IQueryEnvironment &queryEnv) const = 0;
+    virtual FeatureExecutor &createExecutor(const IQueryEnvironment &queryEnv,
+                                            vespalib::Stash &stash) const = 0;
 
     /**
      * Virtual destructor to allow safe subclassing.
diff --git a/searchlib/src/vespa/searchlib/fef/featureexecutor.h b/searchlib/src/vespa/searchlib/fef/featureexecutor.h
index 75110889ab7..a95f9e8dfaf 100644
--- a/searchlib/src/vespa/searchlib/fef/featureexecutor.h
+++ b/searchlib/src/vespa/searchlib/fef/featureexecutor.h
@@ -87,13 +87,6 @@ private:
 
 public:
     /**
-     * Convenience typedef for a shared pointer to this class.
-     **/
-    typedef vespalib::LinkedPtr<FeatureExecutor> LP;
-
-    typedef std::unique_ptr<FeatureExecutor> UP;
-
-    /**
      * Create a feature executor that has not yet been bound to neither
      * inputs nor outputs.
      **/
diff --git a/searchlib/src/vespa/searchlib/fef/featureoverrider.cpp b/searchlib/src/vespa/searchlib/fef/featureoverrider.cpp
index 5bb2a2789bf..be772b6b8e2 100644
--- a/searchlib/src/vespa/searchlib/fef/featureoverrider.cpp
+++ b/searchlib/src/vespa/searchlib/fef/featureoverrider.cpp
@@ -6,7 +6,7 @@
 namespace search {
 namespace fef {
 
-FeatureOverrider::FeatureOverrider(FeatureExecutor::LP executor, uint32_t outputIdx, feature_t value)
+FeatureOverrider::FeatureOverrider(FeatureExecutor &executor, uint32_t outputIdx, feature_t value)
     : _executor(executor),
       _outputIdx(outputIdx),
       _handle(IllegalHandle),
@@ -18,9 +18,9 @@ void
 FeatureOverrider::inputs_done()
 {
     for (uint32_t i = 0; i < inputs().size(); ++i) {
-        _executor->addInput(inputs()[i]);
+        _executor.addInput(inputs()[i]);
     }
-    _executor->inputs_done();
+    _executor.inputs_done();
 }
 
 void
@@ -30,21 +30,21 @@ FeatureOverrider::outputs_done()
         _handle = outputs()[_outputIdx];
     }
     for (uint32_t i = 0; i < outputs().size(); ++i) {
-        _executor->bindOutput(outputs()[i]);
+        _executor.bindOutput(outputs()[i]);
     }
-    _executor->outputs_done();
+    _executor.outputs_done();
 }
 
 bool
 FeatureOverrider::isPure()
 {
-    return _executor->isPure();
+    return _executor.isPure();
 }
 
 void
 FeatureOverrider::execute(MatchData &data)
 {
-    _executor->execute(data);
+    _executor.execute(data);
     if (_handle != IllegalHandle) {
         *data.resolveFeature(_handle) = _value;
     }
diff --git a/searchlib/src/vespa/searchlib/fef/featureoverrider.h b/searchlib/src/vespa/searchlib/fef/featureoverrider.h
index 432a8ea4736..d54454df299 100644
--- a/searchlib/src/vespa/searchlib/fef/featureoverrider.h
+++ b/searchlib/src/vespa/searchlib/fef/featureoverrider.h
@@ -20,7 +20,7 @@ private:
     FeatureOverrider(const FeatureOverrider &);
     FeatureOverrider &operator=(const FeatureOverrider &);
 
-    FeatureExecutor::LP _executor;
+    FeatureExecutor &   _executor;
     uint32_t            _outputIdx;
     FeatureHandle       _handle;
     feature_t           _value;
@@ -34,7 +34,7 @@ public:
      * @param outputIdx which output to override
      * @param value what value to override with
      **/
-    FeatureOverrider(FeatureExecutor::LP executor, uint32_t outputIdx, feature_t value);
+    FeatureOverrider(FeatureExecutor &executor, uint32_t outputIdx, feature_t value);
     void inputs_done() override;
     void outputs_done() override;
     bool isPure() override;
diff --git a/searchlib/src/vespa/searchlib/fef/fef.h b/searchlib/src/vespa/searchlib/fef/fef.h
index 94ac5daf26e..9e6f97d3be4 100644
--- a/searchlib/src/vespa/searchlib/fef/fef.h
+++ b/searchlib/src/vespa/searchlib/fef/fef.h
@@ -49,7 +49,6 @@
 #include "ranksetup.h"
 #include "simpletermdata.h"
 #include "simpletermfielddata.h"
-#include "sumexecutor.h"
 #include "symmetrictable.h"
 #include "table.h"
 #include "tablemanager.h"
diff --git a/searchlib/src/vespa/searchlib/fef/rank_program.cpp b/searchlib/src/vespa/searchlib/fef/rank_program.cpp
index 69cd76917cd..8270e30cfed 100644
--- a/searchlib/src/vespa/searchlib/fef/rank_program.cpp
+++ b/searchlib/src/vespa/searchlib/fef/rank_program.cpp
@@ -82,7 +82,7 @@ RankProgram::add_unboxing_executors(MatchDataLayout &my_mdl)
         if (specs[seed.executor].output_types[seed.output]) {
             FeatureHandle old_handle = _executors[seed.executor]->outputs()[seed.output];
             FeatureHandle new_handle = my_mdl.allocFeature(false);
-            _executors.emplace_back(new UnboxingExecutor(_shared_inputs, old_handle, new_handle));
+            _executors.emplace_back(&_stash.create<UnboxingExecutor>(_shared_inputs, old_handle, new_handle));
             _unboxed_seeds[seed_entry.first] = std::make_pair(old_handle, new_handle);
         }
     }
@@ -116,6 +116,7 @@ RankProgram::RankProgram(BlueprintResolver::SP resolver)
     : _resolver(resolver),
       _shared_inputs(),
       _program(),
+      _stash(),
       _executors(),
       _unboxed_seeds()
 {
@@ -135,12 +136,12 @@ RankProgram::setup(const MatchDataLayout &mdl_in,
     const auto &specs = _resolver->getExecutorSpecs();
     _executors.reserve(specs.size());
     for (uint32_t i = 0; i < specs.size(); ++i) {
-        FeatureExecutor::UP executor(specs[i].blueprint->createExecutor(queryEnv).release());
+        FeatureExecutor *executor = &(specs[i].blueprint->createExecutor(queryEnv, _stash));
         assert(executor);
         executor->bind_shared_inputs(_shared_inputs);
         for (; (override < override_end) && (override->ref.executor == i); ++override) {
-            FeatureExecutor::LP tmp(executor.release());
-            executor.reset(new FeatureOverrider(tmp, override->ref.output, override->value));
+            FeatureExecutor *tmp = executor;
+            executor = &(_stash.create<FeatureOverrider>(*tmp, override->ref.output, override->value));
             executor->bind_shared_inputs(_shared_inputs);
         }
         for (auto ref: specs[i].inputs) {
@@ -152,7 +153,7 @@ RankProgram::setup(const MatchDataLayout &mdl_in,
             executor->bindOutput(my_mdl.allocFeature(specs[i].output_types[out_idx]));
         }
         executor->outputs_done();
-        _executors.push_back(std::move(executor));
+        _executors.push_back(executor);
     }
     add_unboxing_executors(my_mdl);
     _match_data = my_mdl.createMatchData();
@@ -163,7 +164,7 @@ namespace {
 
 template <typename Each>
 void extract_handles(const BlueprintResolver::FeatureMap &features,
-                     const std::vector<FeatureExecutor::UP> &executors,
+                     const std::vector<FeatureExecutor *> &executors,
                      const Each &each)
 {
     each.reserve(features.size());
diff --git a/searchlib/src/vespa/searchlib/fef/rank_program.h b/searchlib/src/vespa/searchlib/fef/rank_program.h
index d9ac2e0e68b..acc2c11e692 100644
--- a/searchlib/src/vespa/searchlib/fef/rank_program.h
+++ b/searchlib/src/vespa/searchlib/fef/rank_program.h
@@ -33,7 +33,8 @@ private:
     FeatureExecutor::SharedInputs            _shared_inputs;
     std::vector<FeatureExecutor*>            _program;
     MatchData::UP                            _match_data;
-    std::vector<FeatureExecutor::UP>         _executors;
+    vespalib::Stash                          _stash;
+    std::vector<FeatureExecutor *> _executors;
     std::map<vespalib::string, MappedHandle> _unboxed_seeds;
 
     /**
diff --git a/searchlib/src/vespa/searchlib/fef/sumexecutor.cpp b/searchlib/src/vespa/searchlib/fef/sumexecutor.cpp
deleted file mode 100644
index 06df6a6d909..00000000000
--- a/searchlib/src/vespa/searchlib/fef/sumexecutor.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#include <vespa/fastos/fastos.h>
-#include "sumexecutor.h"
-#include "matchdata.h"
-
-namespace search {
-namespace fef {
-
-void
-SumExecutor::execute(MatchData &data)
-{
-    feature_t sum = 0.0;
-    for (uint32_t i = 0; i < inputs().size(); ++i) {
-        sum += *data.resolveFeature(inputs()[i]);
-    }
-    *data.resolveFeature(outputs()[0]) = sum;
-}
-
-} // namespace fef
-} // namespace search
diff --git a/searchlib/src/vespa/searchlib/fef/sumexecutor.h b/searchlib/src/vespa/searchlib/fef/sumexecutor.h
deleted file mode 100644
index 82f5ea237b3..00000000000
--- a/searchlib/src/vespa/searchlib/fef/sumexecutor.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#pragma once
-
-#include "featureexecutor.h"
-
-namespace search {
-namespace fef {
-
-class MatchData;
-
-/**
- * Simple executor that calculates the sum of a set of inputs. This
- * will be moved to another library as it is not really part of the
- * framework.
- **/
-class SumExecutor : public FeatureExecutor
-{
-public:
-    virtual void execute(MatchData &data);
-
-    /**
-     * Create an instance of this class and return it as a shared pointer.
-     *
-     * @return shared pointer to new instance
-     **/
-    static FeatureExecutor::LP create() { return FeatureExecutor::LP(new SumExecutor()); }
-};
-
-} // namespace fef
-} // namespace search
-
diff --git a/searchlib/src/vespa/searchlib/fef/test/plugin/cfgvalue.cpp b/searchlib/src/vespa/searchlib/fef/test/plugin/cfgvalue.cpp
index f36c7588b4b..9f0ae381aaa 100644
--- a/searchlib/src/vespa/searchlib/fef/test/plugin/cfgvalue.cpp
+++ b/searchlib/src/vespa/searchlib/fef/test/plugin/cfgvalue.cpp
@@ -53,6 +53,13 @@ CfgValueBlueprint::setup(const IIndexEnvironment &indexEnv, const StringVector &
     return true;
 }
 
+FeatureExecutor &
+CfgValueBlueprint::createExecutor(const IQueryEnvironment & queryEnv, vespalib::Stash &stash) const
+{
+    (void) queryEnv;
+    return stash.create<search::features::ValueExecutor>(_values);
+}
+
 } // namespace test
 } // namespace fef
 } // namespace search
diff --git a/searchlib/src/vespa/searchlib/fef/test/plugin/cfgvalue.h b/searchlib/src/vespa/searchlib/fef/test/plugin/cfgvalue.h
index 975101620e2..35ab0523076 100644
--- a/searchlib/src/vespa/searchlib/fef/test/plugin/cfgvalue.h
+++ b/searchlib/src/vespa/searchlib/fef/test/plugin/cfgvalue.h
@@ -22,10 +22,7 @@ public:
     virtual void visitDumpFeatures(const IIndexEnvironment & indexEnv, IDumpFeatureVisitor & visitor) const;
     virtual Blueprint::UP createInstance() const { return Blueprint::UP(new CfgValueBlueprint()); }
     virtual bool setup(const IIndexEnvironment & indexEnv, const StringVector & params);
-    virtual FeatureExecutor::LP createExecutor(const IQueryEnvironment & queryEnv) const override {
-        (void) queryEnv;
-        return FeatureExecutor::LP(new search::features::ValueExecutor(_values));
-    }
+    virtual FeatureExecutor &createExecutor(const IQueryEnvironment & queryEnv, vespalib::Stash &stash) const override;
 };
 
 } // namespace test
diff --git a/searchlib/src/vespa/searchlib/fef/test/plugin/chain.cpp b/searchlib/src/vespa/searchlib/fef/test/plugin/chain.cpp
index 33567dd1a67..430bbe51416 100644
--- a/searchlib/src/vespa/searchlib/fef/test/plugin/chain.cpp
+++ b/searchlib/src/vespa/searchlib/fef/test/plugin/chain.cpp
@@ -64,6 +64,13 @@ ChainBlueprint::setup(const IIndexEnvironment & indexEnv, const StringVector & p
     return true;
 }
 
+FeatureExecutor &
+ChainBlueprint::createExecutor(const IQueryEnvironment &queryEnv, vespalib::Stash &stash) const
+{
+    (void) queryEnv;
+    return stash.create<ChainExecutor>();
+}
+
 } // namespace test
 } // namespace fef
 } // namespace search
diff --git a/searchlib/src/vespa/searchlib/fef/test/plugin/chain.h b/searchlib/src/vespa/searchlib/fef/test/plugin/chain.h
index 8215b5ae73f..d82abcedb59 100644
--- a/searchlib/src/vespa/searchlib/fef/test/plugin/chain.h
+++ b/searchlib/src/vespa/searchlib/fef/test/plugin/chain.h
@@ -26,10 +26,7 @@ public:
     virtual void visitDumpFeatures(const IIndexEnvironment &, IDumpFeatureVisitor &) const {}
     virtual Blueprint::UP createInstance() const { return Blueprint::UP(new ChainBlueprint()); }
     virtual bool setup(const IIndexEnvironment & indexEnv, const StringVector & params);
-    virtual FeatureExecutor::LP createExecutor(const IQueryEnvironment & queryEnv) const override {
-        (void) queryEnv;
-        return FeatureExecutor::LP(new ChainExecutor());
-    }
+    virtual FeatureExecutor &createExecutor(const IQueryEnvironment & queryEnv, vespalib::Stash &stash) const;
 };
 
 } // namespace test
diff --git a/searchlib/src/vespa/searchlib/fef/test/plugin/double.cpp b/searchlib/src/vespa/searchlib/fef/test/plugin/double.cpp
index 724b8597ece..38b6c46b502 100644
--- a/searchlib/src/vespa/searchlib/fef/test/plugin/double.cpp
+++ b/searchlib/src/vespa/searchlib/fef/test/plugin/double.cpp
@@ -54,6 +54,13 @@ DoubleBlueprint::setup(const IIndexEnvironment & indexEnv, const StringVector &
     return true;
 }
 
+FeatureExecutor &
+DoubleBlueprint::createExecutor(const IQueryEnvironment &queryEnv, vespalib::Stash &stash) const
+{
+    (void) queryEnv;
+    return stash.create<DoubleExecutor>(_cnt);
+}
+
 } // namespace test
 } // namespace fef
 } // namespace search
diff --git a/searchlib/src/vespa/searchlib/fef/test/plugin/double.h b/searchlib/src/vespa/searchlib/fef/test/plugin/double.h
index 4f5fbf5e3a6..2b29f56e131 100644
--- a/searchlib/src/vespa/searchlib/fef/test/plugin/double.h
+++ b/searchlib/src/vespa/searchlib/fef/test/plugin/double.h
@@ -30,10 +30,7 @@ public:
     virtual void visitDumpFeatures(const IIndexEnvironment & indexEnv, IDumpFeatureVisitor & visitor) const;
     virtual Blueprint::UP createInstance() const { return Blueprint::UP(new DoubleBlueprint()); }
     virtual bool setup(const IIndexEnvironment & indexEnv, const StringVector & params);
-    virtual FeatureExecutor::LP createExecutor(const IQueryEnvironment & queryEnv) const override {
-        (void) queryEnv;
-        return FeatureExecutor::LP(new DoubleExecutor(_cnt));
-    }
+    virtual FeatureExecutor &createExecutor(const IQueryEnvironment &queryEnv, vespalib::Stash &stash) const override;
 };
 
 } // namespace test
diff --git a/searchlib/src/vespa/searchlib/fef/test/plugin/query.cpp b/searchlib/src/vespa/searchlib/fef/test/plugin/query.cpp
index 4308bd4908d..60fafd8ae90 100644
--- a/searchlib/src/vespa/searchlib/fef/test/plugin/query.cpp
+++ b/searchlib/src/vespa/searchlib/fef/test/plugin/query.cpp
@@ -32,13 +32,13 @@ QueryBlueprint::setup(const IIndexEnvironment &indexEnv, const StringVector &par
     return true;
 }
 
-FeatureExecutor::LP
-QueryBlueprint::createExecutor(const IQueryEnvironment &queryEnv) const
+FeatureExecutor &
+QueryBlueprint::createExecutor(const IQueryEnvironment &queryEnv, vespalib::Stash &stash) const
 {
     std::vector<feature_t> values;
     std::string val = queryEnv.getProperties().lookup(_key).get("0.0");
     values.push_back(strtod(val.data(), NULL));
-    return FeatureExecutor::LP(new search::features::ValueExecutor(values));
+    return stash.create<search::features::ValueExecutor>(values);
 }
 
 } // namespace test
diff --git a/searchlib/src/vespa/searchlib/fef/test/plugin/query.h b/searchlib/src/vespa/searchlib/fef/test/plugin/query.h
index c09f595b5f6..23f9392d2f8 100644
--- a/searchlib/src/vespa/searchlib/fef/test/plugin/query.h
+++ b/searchlib/src/vespa/searchlib/fef/test/plugin/query.h
@@ -21,7 +21,7 @@ public:
     virtual void visitDumpFeatures(const IIndexEnvironment &, IDumpFeatureVisitor &) const {};
     virtual Blueprint::UP createInstance() const { return Blueprint::UP(new QueryBlueprint()); }
     virtual bool setup(const IIndexEnvironment &indexEnv, const StringVector &params);
-    virtual FeatureExecutor::LP createExecutor(const IQueryEnvironment &queryEnv) const override;
+    virtual FeatureExecutor &createExecutor(const IQueryEnvironment &queryEnv, vespalib::Stash &stash) const override;
 };
 
 } // namespace test
diff --git a/searchlib/src/vespa/searchlib/fef/test/plugin/staticrank.cpp b/searchlib/src/vespa/searchlib/fef/test/plugin/staticrank.cpp
index 502115b2b1b..6123a789803 100644
--- a/searchlib/src/vespa/searchlib/fef/test/plugin/staticrank.cpp
+++ b/searchlib/src/vespa/searchlib/fef/test/plugin/staticrank.cpp
@@ -47,11 +47,11 @@ StaticRankBlueprint::setup(const IIndexEnvironment & indexEnv, const StringVecto
     return true;
 }
 
-FeatureExecutor::LP
-StaticRankBlueprint::createExecutor(const IQueryEnvironment & queryEnv) const
+FeatureExecutor &
+StaticRankBlueprint::createExecutor(const IQueryEnvironment & queryEnv, vespalib::Stash &stash) const
 {
     const search::attribute::IAttributeVector * av = queryEnv.getAttributeContext().getAttribute(_attributeName);
-    return FeatureExecutor::LP(new StaticRankExecutor(av));
+    return stash.create<StaticRankExecutor>(av);
 }
 
 } // namespace test
diff --git a/searchlib/src/vespa/searchlib/fef/test/plugin/staticrank.h b/searchlib/src/vespa/searchlib/fef/test/plugin/staticrank.h
index d8e5189b166..10467cd8d55 100644
--- a/searchlib/src/vespa/searchlib/fef/test/plugin/staticrank.h
+++ b/searchlib/src/vespa/searchlib/fef/test/plugin/staticrank.h
@@ -32,7 +32,7 @@ public:
     virtual void visitDumpFeatures(const IIndexEnvironment &, IDumpFeatureVisitor &) const {}
     virtual Blueprint::UP createInstance() const { return Blueprint::UP(new StaticRankBlueprint()); }
     virtual bool setup(const IIndexEnvironment & indexEnv, const StringVector & params);
-    virtual FeatureExecutor::LP createExecutor(const IQueryEnvironment & queryEnv) const override;
+    virtual FeatureExecutor &createExecutor(const IQueryEnvironment &queryEnv, vespalib::Stash &stash) const override;
 };
 
 } // namespace test
diff --git a/searchlib/src/vespa/searchlib/fef/test/plugin/sum.cpp b/searchlib/src/vespa/searchlib/fef/test/plugin/sum.cpp
index e5e8e3dedc0..9687ceb43de 100644
--- a/searchlib/src/vespa/searchlib/fef/test/plugin/sum.cpp
+++ b/searchlib/src/vespa/searchlib/fef/test/plugin/sum.cpp
@@ -69,6 +69,13 @@ SumBlueprint::setup(const IIndexEnvironment & indexEnv, const StringVector & par
     return true;
 }
 
+FeatureExecutor &
+SumBlueprint::createExecutor(const IQueryEnvironment &queryEnv, vespalib::Stash &stash) const
+{
+    (void) queryEnv;
+    return stash.create<SumExecutor>();
+}
+
 } // namespace test
 } // namespace fef
 } // namespace search
diff --git a/searchlib/src/vespa/searchlib/fef/test/plugin/sum.h b/searchlib/src/vespa/searchlib/fef/test/plugin/sum.h
index 63691e76569..e62b6dd9cbf 100644
--- a/searchlib/src/vespa/searchlib/fef/test/plugin/sum.h
+++ b/searchlib/src/vespa/searchlib/fef/test/plugin/sum.h
@@ -26,10 +26,7 @@ public:
     virtual void visitDumpFeatures(const IIndexEnvironment & indexEnv, IDumpFeatureVisitor & visitor) const;
     virtual Blueprint::UP createInstance() const { return Blueprint::UP(new SumBlueprint()); }
     virtual bool setup(const IIndexEnvironment & indexEnv, const StringVector & params);
-    virtual FeatureExecutor::LP createExecutor(const IQueryEnvironment & queryEnv) const override {
-        (void) queryEnv;
-        return FeatureExecutor::LP(new SumExecutor());
-    }
+    virtual FeatureExecutor &createExecutor(const IQueryEnvironment & queryEnv, vespalib::Stash &stash) const override;
 };
 
 } // namespace test