Merge pull request #894 from yahoo/balder/always-provide-coverage

Balder/always provide coverage

10 files changed, 211 insertions, 821 deletions

diff --git a/searchlib/src/tests/common/packets/packets_test.cpp b/searchlib/src/tests/common/packets/packets_test.cpp
index 443436537e1..9e8f6698220 100644
--- a/searchlib/src/tests/common/packets/packets_test.cpp
+++ b/searchlib/src/tests/common/packets/packets_test.cpp
@@ -136,6 +136,16 @@ TEST("testPacketFactory") {
     for (uint32_t pcode = PCODE_BEGIN; pcode < PCODE_END; ++pcode) {
         if ((pcode != PCODE_MLD_QUERYRESULT2_NOTUSED) &&
             (pcode != PCODE_QUERY_NOTUSED) &&
+            (pcode != PCODE_MONITORQUERY_NOTUSED) &&
+            (pcode != PCODE_GETDOCSUMS_NOTUSED) &&
+            (pcode != PCODE_MLD_GETDOCSUMS_NOTUSED) &&
+            (pcode != PCODE_QUERYRESULT_NOTUSED) &&
+            (pcode != PCODE_MLD_QUERYRESULT_NOTUSED) &&
+            (pcode != PCODE_MONITORRESULT_NOTUSED) &&
+            (pcode != PCODE_MLD_MONITORRESULT_NOTUSED) &&
+            (pcode != PCODE_CLEARCACHES_NOTUSED) &&
+            (pcode != PCODE_PARSEDQUERY2_NOTUSED) &&
+            (pcode != PCODE_QUEUELEN_NOTUSED) &&
             (pcode != PCODE_QUERY2_NOTUSED) &&
             (pcode != PCODE_MLD_GETDOCSUMS2_NOTUSED))
         {
@@ -306,42 +316,6 @@ TEST("testMonitorResultX") {
     }
 }
 
-TEST("testClearCaches") {
-    FS4Packet_CLEARCACHES *src = dynamic_cast<FS4Packet_CLEARCACHES*>(FS4PacketFactory::CreateFS4Packet(PCODE_CLEARCACHES));
-    ASSERT_TRUE(src != NULL);
-
-    std::vector<FNET_Packet*> lst { src, testEncodeDecode(*src) };
-
-    for (FNET_Packet * packet : lst) {
-        FS4Packet_CLEARCACHES *ptr = dynamic_cast<FS4Packet_CLEARCACHES*>(packet);
-        ASSERT_TRUE(ptr != NULL);
-        EXPECT_EQUAL((uint32_t)PCODE_CLEARCACHES, ptr->GetPCODE());
-        EXPECT_EQUAL(0u, ptr->GetLength());
-
-        delete ptr;
-    }
-}
-
-TEST("testQueueLen") {
-    FS4Packet_QUEUELEN *src = dynamic_cast<FS4Packet_QUEUELEN*>(FS4PacketFactory::CreateFS4Packet(PCODE_QUEUELEN));
-    ASSERT_TRUE(src != NULL);
-    src->_queueLen = 1u;
-    src->_dispatchers = 2u;
-
-    std::vector<FNET_Packet*> lst { src, testEncodeDecode(*src) };
-
-    for (FNET_Packet * packet : lst) {
-        FS4Packet_QUEUELEN *ptr = dynamic_cast<FS4Packet_QUEUELEN*>(packet);
-        ASSERT_TRUE(ptr != NULL);
-        EXPECT_EQUAL((uint32_t)PCODE_QUEUELEN, ptr->GetPCODE());
-        EXPECT_EQUAL(8u, ptr->GetLength());
-        EXPECT_EQUAL(1u, ptr->_queueLen);
-        EXPECT_EQUAL(2u, ptr->_dispatchers);
-
-        delete ptr;
-    }
-}
-
 TEST("testQueryResultX") {
     FS4Packet_QUERYRESULTX *src = dynamic_cast<FS4Packet_QUERYRESULTX*>(FS4PacketFactory::CreateFS4Packet(PCODE_QUERYRESULTX));
     ASSERT_TRUE(src != NULL);
@@ -353,7 +327,6 @@ TEST("testQueryResultX") {
     src->_activeDocs = 7u;
     uint32_t sortIndex[3] = { 0u, 1u, 3u /* size of data */}; // numDocs + 1
     src->SetSortDataRef(2, sortIndex, "foo");
-    src->SetAggrDataRef("bar", 3u);
     src->SetGroupDataRef("baz", 3u);
     src->AllocateHits(2);
     src->_hits[0]._gid = gid0;
@@ -396,12 +369,6 @@ TEST("testQueryResultX") {
             EXPECT_EQUAL((void*)NULL, ptr->_sortIndex);
             EXPECT_EQUAL((void*)NULL, ptr->_sortData);
         }
-        if (ptr->_features & QRF_AGGRDATA) {
-            EXPECT_EQUAL("bar", std::string(ptr->_aggrData, ptr->_aggrDataLen));
-        } else {
-            EXPECT_EQUAL(0u, ptr->_aggrDataLen);
-            EXPECT_EQUAL((void*)NULL, ptr->_aggrData);
-        }
         if (ptr->_features & QRF_GROUPDATA) {
             EXPECT_EQUAL("baz", std::string(ptr->_groupData, ptr->_groupDataLen));
         } else {
@@ -440,7 +407,6 @@ createAndFill_QUERYX()
     fillProperties(src->_propsVector[0], "foo", 8);
     fillProperties(src->_propsVector[1], "bar", 16);
     src->setSortSpec("sortspec");
-    src->setAggrSpec("aggrspec");
     src->setGroupSpec("groupspec");
     src->setLocation("location");
     src->setStackDump("stackdump");
@@ -474,11 +440,6 @@ verifyQueryX(FS4Packet_QUERYX & queryX, uint32_t features)
     } else {
         EXPECT_EQUAL(0u, queryX._sortSpec.size());
     }
-    if (queryX._features & QF_AGGRSPEC) {
-        EXPECT_EQUAL("aggrspec", queryX._aggrSpec);
-    } else {
-        EXPECT_EQUAL(0u, queryX._aggrSpec.size());
-    }
     if (queryX._features & QF_GROUPSPEC) {
         EXPECT_EQUAL("groupspec", queryX._groupSpec);
     } else {
@@ -545,13 +506,13 @@ TEST("test pre serializing packets no compression") {
     queryX->_features=FNET_QF_SUPPORTED_MASK;
     FNET_Packet::UP decoded(testEncodeDecode(*src));
     verifyQueryX(*static_cast<FS4Packet_QUERYX *>(decoded.get()), FNET_QF_SUPPORTED_MASK);
-    EXPECT_EQUAL(512u, src->GetLength());
+    EXPECT_EQUAL(500u, src->GetLength());
     EXPECT_EQUAL(src->GetLength(), decoded->GetLength());
     FS4Packet_PreSerialized serialized(*src);
     EXPECT_EQUAL(218u, serialized.GetPCODE());
-    EXPECT_EQUAL(512u, serialized.GetLength());
+    EXPECT_EQUAL(500u, serialized.GetLength());
     FNET_Packet::UP decoded2(testEncodeDecode(serialized));
-    EXPECT_EQUAL(512u, decoded2->GetLength());
+    EXPECT_EQUAL(500u, decoded2->GetLength());
     verifyQueryX(*static_cast<FS4Packet_QUERYX *>(decoded2.get()), FNET_QF_SUPPORTED_MASK);
 }
 
@@ -561,14 +522,14 @@ TEST("test pre serializing packets with compression") {
     queryX->_features=FNET_QF_SUPPORTED_MASK;
     FNET_Packet::UP decoded(testEncodeDecode(*src));
     verifyQueryX(*static_cast<FS4Packet_QUERYX *>(decoded.get()), FNET_QF_SUPPORTED_MASK);
-    EXPECT_EQUAL(512u, src->GetLength());
+    EXPECT_EQUAL(500u, src->GetLength());
     EXPECT_EQUAL(src->GetLength(), decoded->GetLength());
     FS4PersistentPacketStreamer::Instance.SetCompressionLimit(100);
     FS4Packet_PreSerialized serialized(*src);
     EXPECT_EQUAL(218u | (document::CompressionConfig::LZ4 << 24), serialized.GetPCODE());
     EXPECT_GREATER_EQUAL(321u, serialized.GetLength());
     FNET_Packet::UP decoded2(testEncodeDecode(serialized));
-    EXPECT_EQUAL(512u, decoded2->GetLength());
+    EXPECT_EQUAL(500u, decoded2->GetLength());
     verifyQueryX(*static_cast<FS4Packet_QUERYX *>(decoded2.get()), FNET_QF_SUPPORTED_MASK);
 }
     
@@ -645,9 +606,8 @@ TEST("testGetDocsumsX") {
         } else {
             EXPECT_EQUAL(0u, ptr->_flags);
         }
-        EXPECT_EQUAL(2u, ptr->_docidCnt);
-        ASSERT_TRUE(ptr->_docid != NULL);
-        for (uint32_t i = 0; i < ptr->_docidCnt; ++i) {
+        EXPECT_EQUAL(2u, ptr->_docid.size());
+        for (uint32_t i = 0; i < ptr->_docid.size(); ++i) {
             EXPECT_EQUAL(i == 0u ? gid0 : gid1, ptr->_docid[i]._gid);
             EXPECT_EQUAL(ptr->_features & GDF_MLD ? 2u + i : 0u, ptr->_docid[i]._partid);
         }
diff --git a/searchlib/src/tests/engine/searchapi/searchapi_test.cpp b/searchlib/src/tests/engine/searchapi/searchapi_test.cpp
index cd040bfaeac..ce850c9e1e1 100644
--- a/searchlib/src/tests/engine/searchapi/searchapi_test.cpp
+++ b/searchlib/src/tests/engine/searchapi/searchapi_test.cpp
@@ -74,8 +74,6 @@ Test::convertToRequest()
     src._propsVector[1].setValue(1, "p2v2", strlen("p2v2"));
     src._features |= QF_SORTSPEC;
     src.setSortSpec("sortspec");
-    src._features |= QF_AGGRSPEC;
-    src.setAggrSpec("aggrspec");
     src._features |= QF_GROUPSPEC;
     src.setGroupSpec("groupspec");
     src._features |= QF_SESSIONID;
@@ -133,7 +131,6 @@ Test::convertFromReply()
     src.sortData.push_back(11);
     src.sortData.push_back(22);
     src.groupResult.push_back(2);
-    src.useCoverage = true;
     src.coverage = SearchReply::Coverage(5, 3);
     src.useWideHits = true;
     src.hits.resize(2);
@@ -214,16 +211,6 @@ Test::convertFromReply()
         EXPECT_EQUAL(dst._coverageDocs, 3u);
         EXPECT_EQUAL(dst._activeDocs, 5u);
     }
-    { // not coverage
-        SearchReply cpy = src;
-        cpy.useCoverage = false;
-
-        FS4Packet_QUERYRESULTX dst0;
-        PacketConverter::fromSearchReply(cpy, dst0);
-        FS4Packet_QUERYRESULTX dst;
-        copyPacket(dst0, dst);
-        EXPECT_TRUE(checkNotFeature(dst._features, QRF_COVERAGE));
-    }
     { // non-mld
         SearchReply cpy = src;
         cpy.useWideHits = false;
diff --git a/searchlib/src/vespa/searchlib/common/packets.cpp b/searchlib/src/vespa/searchlib/common/packets.cpp
index 769cbbeeed4..274188c87f9 100644
--- a/searchlib/src/vespa/searchlib/common/packets.cpp
+++ b/searchlib/src/vespa/searchlib/common/packets.cpp
@@ -39,18 +39,13 @@ bool
 FS4PersistentPacketStreamer::HasChannelID(uint32_t pcode)
 {
     switch(pcode & PCODE_MASK) {
-    case search::fs4transport::PCODE_EOL:
-    case search::fs4transport::PCODE_QUERYRESULT:
-    case search::fs4transport::PCODE_ERROR:
-    case search::fs4transport::PCODE_GETDOCSUMS:
-    case search::fs4transport::PCODE_DOCSUM:
-    case search::fs4transport::PCODE_MLD_QUERYRESULT:
-    case search::fs4transport::PCODE_MLD_GETDOCSUMS:
-    case search::fs4transport::PCODE_PARSEDQUERY2:
-    case search::fs4transport::PCODE_QUERYRESULTX:
-    case search::fs4transport::PCODE_QUERYX:
-    case search::fs4transport::PCODE_GETDOCSUMSX:
-    case search::fs4transport::PCODE_TRACEREPLY:
+    case PCODE_EOL:
+    case PCODE_ERROR:
+    case PCODE_DOCSUM:
+    case PCODE_QUERYRESULTX:
+    case PCODE_QUERYX:
+    case PCODE_GETDOCSUMSX:
+    case PCODE_TRACEREPLY:
         return true;
     default:
         return false;
@@ -668,7 +663,7 @@ FS4Packet_DOCSUM::toString(uint32_t indent) const
     s += make_string("%*sFS4Packet_DOCSUM {\n", indent, "");
     s += make_string("%*s  gid       : %s\n", indent, "", _gid.toString().c_str());
 
-    uint32_t magic = ::search::fs4transport::SLIME_MAGIC_ID;
+    uint32_t magic = SLIME_MAGIC_ID;
     if (_buf.size() >= sizeof(magic) &&
         memcmp(_buf.c_str(), &magic, sizeof(magic)) == 0) {
         vespalib::Slime slime;
@@ -699,13 +694,11 @@ FS4Packet_DOCSUM::toString(uint32_t indent) const
 
 //============================================================
 
-FS4Packet_MONITORQUERYX::FS4Packet_MONITORQUERYX(uint32_t pcode)
+FS4Packet_MONITORQUERYX::FS4Packet_MONITORQUERYX()
     : FS4Packet(),
-      _pcode(pcode),
       _features(0),
       _qflags(0u)
 {
-    UpdateCompatFeatures();
 }
 
 
@@ -714,32 +707,13 @@ FS4Packet_MONITORQUERYX::~FS4Packet_MONITORQUERYX()
 }
 
 
-void
-FS4Packet_MONITORQUERYX::UpdateCompatPCODE(void)
-{
-    if (_features == search::fs4transport::MQF_MONITORQUERY_MASK)
-        _pcode =    search::fs4transport::PCODE_MONITORQUERY;
-    else
-        _pcode = search::fs4transport::PCODE_MONITORQUERYX;
-}
-
-
-void
-FS4Packet_MONITORQUERYX::UpdateCompatFeatures(void)
-{
-    if (_pcode == search::fs4transport::PCODE_MONITORQUERY)
-        _features =    search::fs4transport::MQF_MONITORQUERY_MASK;
-}
-
-
 uint32_t
 FS4Packet_MONITORQUERYX::GetLength()
 {
     uint32_t plen = 0;
 
-    if (_pcode == search::fs4transport::PCODE_MONITORQUERYX)
-        plen += sizeof(uint32_t);
-    if (_features & search::fs4transport::MQF_QFLAGS)
+    plen += sizeof(uint32_t);
+    if (_features & MQF_QFLAGS)
         plen += sizeof(uint32_t);
     return plen;
 }
@@ -748,10 +722,9 @@ FS4Packet_MONITORQUERYX::GetLength()
 void
 FS4Packet_MONITORQUERYX::Encode(FNET_DataBuffer *dst)
 {
-    if (_pcode == search::fs4transport::PCODE_MONITORQUERYX)
-        dst->WriteInt32Fast(_features);
+    dst->WriteInt32Fast(_features);
 
-    if ((_features & search::fs4transport::MQF_QFLAGS) != 0)
+    if ((_features & MQF_QFLAGS) != 0)
         dst->WriteInt32Fast(_qflags);
 }
 
@@ -759,16 +732,14 @@ FS4Packet_MONITORQUERYX::Encode(FNET_DataBuffer *dst)
 bool
 FS4Packet_MONITORQUERYX::Decode(FNET_DataBuffer *src, uint32_t len)
 {
-    if (_pcode == search::fs4transport::PCODE_MONITORQUERYX) {
-        if (len < sizeof(uint32_t))
-            goto error;
-        _features = src->ReadInt32();
-        len -= sizeof(uint32_t);
-    }
-    if ((_features & ~search::fs4transport::FNET_MQF_SUPPORTED_MASK) != 0)
+    if (len < sizeof(uint32_t))
+        goto error;
+    _features = src->ReadInt32();
+    len -= sizeof(uint32_t);
+    if ((_features & ~FNET_MQF_SUPPORTED_MASK) != 0)
         goto error;
 
-    if ((_features & search::fs4transport::MQF_QFLAGS) != 0) {
+    if ((_features & MQF_QFLAGS) != 0) {
         if (len < sizeof(uint32_t))
             goto error;
         _qflags = src->ReadInt32();
@@ -778,8 +749,7 @@ FS4Packet_MONITORQUERYX::Decode(FNET_DataBuffer *src, uint32_t len)
     if (len != 0)
         goto error;
 
-    SetRealPCODE();
-    return true;			// OK
+    return true;
  error:
     src->DataToDead(len);
     return false;			// FAIL
@@ -791,7 +761,6 @@ FS4Packet_MONITORQUERYX::toString(uint32_t indent) const
 {
     vespalib::string s;
     s += make_string("%*sFS4Packet_MONITORQUERYX {\n", indent, "");
-    s += make_string("%*s  pcode       : %d\n", indent, "", _pcode);
     s += make_string("%*s  features    : 0x%x\n", indent, "", _features);
     s += make_string("%*s  qflags      : %d\n", indent, "", _qflags);
     s += make_string("%*s}\n", indent, "");
@@ -800,10 +769,8 @@ FS4Packet_MONITORQUERYX::toString(uint32_t indent) const
 
 //============================================================
 
-FS4Packet_MONITORRESULTX::
-FS4Packet_MONITORRESULTX(uint32_t pcode)
+FS4Packet_MONITORRESULTX::FS4Packet_MONITORRESULTX()
     : FS4Packet(),
-      _pcode(pcode),
       _features(0),
       _partid(0),
       _timestamp(0),
@@ -813,50 +780,21 @@ FS4Packet_MONITORRESULTX(uint32_t pcode)
       _activeParts(0),
       _rflags(0u),
       _activeDocs(0)
-{
-    UpdateCompatFeatures();
-}
-
-
-FS4Packet_MONITORRESULTX::~FS4Packet_MONITORRESULTX(void)
-{
-}
-
-
-void
-FS4Packet_MONITORRESULTX::UpdateCompatPCODE(void)
-{
-    if (_features == search::fs4transport::MRF_MONITORRESULT_MASK)
-        _pcode =    search::fs4transport::PCODE_MONITORRESULT;
-    else if (_features == search::fs4transport::MRF_MLD_MONITORRESULT_MASK)
-        _pcode =         search::fs4transport::PCODE_MLD_MONITORRESULT;
-    else
-        _pcode = search::fs4transport::PCODE_MONITORRESULTX;
-}
-
-
-void
-FS4Packet_MONITORRESULTX::UpdateCompatFeatures(void)
-{
-    if (_pcode == search::fs4transport::PCODE_MONITORRESULT)
-        _features =    search::fs4transport::MRF_MONITORRESULT_MASK;
-    else if (_pcode == search::fs4transport::PCODE_MLD_MONITORRESULT)
-        _features =         search::fs4transport::MRF_MLD_MONITORRESULT_MASK;
-}
+{ }
 
+FS4Packet_MONITORRESULTX::~FS4Packet_MONITORRESULTX() { }
 
 uint32_t
-FS4Packet_MONITORRESULTX::GetLength(void)
+FS4Packet_MONITORRESULTX::GetLength()
 {
     uint32_t plen = 2 * sizeof(uint32_t);
 
-    if (_pcode == search::fs4transport::PCODE_MONITORRESULTX)
-        plen += sizeof(uint32_t);
-    if ((_features & search::fs4transport::MRF_MLD) != 0)
+    plen += sizeof(uint32_t);
+    if ((_features & MRF_MLD) != 0)
         plen +=  4 * sizeof(uint32_t);
-    if ((_features & search::fs4transport::MRF_RFLAGS) != 0)
+    if ((_features & MRF_RFLAGS) != 0)
         plen += sizeof(uint32_t);
-    if ((_features & search::fs4transport::MRF_ACTIVEDOCS) != 0)
+    if ((_features & MRF_ACTIVEDOCS) != 0)
         plen += sizeof(uint64_t);
 
     return plen;
@@ -866,21 +804,20 @@ FS4Packet_MONITORRESULTX::GetLength(void)
 void
 FS4Packet_MONITORRESULTX::Encode(FNET_DataBuffer *dst)
 {
-    if (_pcode == search::fs4transport::PCODE_MONITORRESULTX)
-        dst->WriteInt32Fast(_features);
+    dst->WriteInt32Fast(_features);
 
     dst->WriteInt32Fast(_partid);
     dst->WriteInt32Fast(_timestamp);
-    if ((_features & search::fs4transport::MRF_MLD) != 0) {
+    if ((_features & MRF_MLD) != 0) {
         dst->WriteInt32Fast(_totalNodes);
         dst->WriteInt32Fast(_activeNodes);
         dst->WriteInt32Fast(_totalParts);
         dst->WriteInt32Fast(_activeParts);
     }
-    if ((_features & search::fs4transport::MRF_RFLAGS) != 0) {
+    if ((_features & MRF_RFLAGS) != 0) {
         dst->WriteInt32Fast(_rflags);
     }
-    if ((_features & search::fs4transport::MRF_ACTIVEDOCS) != 0) {
+    if ((_features & MRF_ACTIVEDOCS) != 0) {
         dst->WriteInt64Fast(_activeDocs);
     }
 }
@@ -889,12 +826,10 @@ FS4Packet_MONITORRESULTX::Encode(FNET_DataBuffer *dst)
 bool
 FS4Packet_MONITORRESULTX::Decode(FNET_DataBuffer *src, uint32_t len)
 {
-    if (_pcode == search::fs4transport::PCODE_MONITORRESULTX) {
-        if (len < sizeof(uint32_t)) goto error;
-        _features = src->ReadInt32();
-        len -= sizeof(uint32_t);
-    }
-    if ((_features & ~search::fs4transport::FNET_MRF_SUPPORTED_MASK) != 0)
+    if (len < sizeof(uint32_t)) goto error;
+    _features = src->ReadInt32();
+    len -= sizeof(uint32_t);
+    if ((_features & ~FNET_MRF_SUPPORTED_MASK) != 0)
         goto error;
 
     if (len < 2 * sizeof(uint32_t))
@@ -903,7 +838,7 @@ FS4Packet_MONITORRESULTX::Decode(FNET_DataBuffer *src, uint32_t len)
     _timestamp   = src->ReadInt32();
     len -= 2 * sizeof(uint32_t);
 
-    if ((_features & search::fs4transport::MRF_MLD) != 0) {
+    if ((_features & MRF_MLD) != 0) {
         if (len < 4 * sizeof(uint32_t))
             goto error;
         _totalNodes  = src->ReadInt32();
@@ -913,14 +848,14 @@ FS4Packet_MONITORRESULTX::Decode(FNET_DataBuffer *src, uint32_t len)
         len -= 4 * sizeof(uint32_t);
     }
 
-    if ((_features & search::fs4transport::MRF_RFLAGS) != 0) {
+    if ((_features & MRF_RFLAGS) != 0) {
         if (len < sizeof(uint32_t))
             goto error;
         _rflags = src->ReadInt32();
         len -= sizeof(uint32_t);
     }
 
-    if ((_features & search::fs4transport::MRF_ACTIVEDOCS) != 0) {
+    if ((_features & MRF_ACTIVEDOCS) != 0) {
         if (len < sizeof(uint64_t))
             goto error;
         _activeDocs = src->ReadInt64();
@@ -930,7 +865,6 @@ FS4Packet_MONITORRESULTX::Decode(FNET_DataBuffer *src, uint32_t len)
     if (len != 0)
         goto error;
 
-    SetRealPCODE();
     return true;			// OK
  error:
     src->DataToDead(len);
@@ -943,7 +877,6 @@ FS4Packet_MONITORRESULTX::toString(uint32_t indent) const
 {
     vespalib::string s;
     s += make_string("%*sFS4Packet_MONITORRESULTX {\n", indent, "");
-    s += make_string("%*s  pcode       : %d\n", indent, "", _pcode);
     s += make_string("%*s  features    : 0x%x\n", indent, "", _features);
     s += make_string("%*s  partid      : %d\n", indent, "", _partid);
     s += make_string("%*s  timestamp   : %d\n", indent, "", _timestamp);
@@ -957,101 +890,6 @@ FS4Packet_MONITORRESULTX::toString(uint32_t indent) const
 
 //============================================================
 
-FS4Packet_CLEARCACHES::FS4Packet_CLEARCACHES()
-    : FS4Packet()
-{
-}
-
-
-FS4Packet_CLEARCACHES::~FS4Packet_CLEARCACHES()
-{
-}
-
-
-uint32_t
-FS4Packet_CLEARCACHES::GetLength()
-{
-    return 0;
-}
-
-
-void
-FS4Packet_CLEARCACHES::Encode(FNET_DataBuffer *dst)
-{
-    (void) dst;
-}
-
-
-bool
-FS4Packet_CLEARCACHES::Decode(FNET_DataBuffer *src, uint32_t len)
-{
-    src->DataToDead(len);
-    return (len == 0);
-}
-
-
-vespalib::string
-FS4Packet_CLEARCACHES::toString(uint32_t indent) const
-{
-    return make_string("%*sFS4Packet_CLEARCACHES {}\n", indent, "");
-}
-
-//============================================================
-
-FS4Packet_QUEUELEN::FS4Packet_QUEUELEN()
-    : FS4Packet(),
-      _queueLen(0),
-      _dispatchers(0)
-{
-}
-
-
-FS4Packet_QUEUELEN::~FS4Packet_QUEUELEN()
-{
-}
-
-
-uint32_t
-FS4Packet_QUEUELEN::GetLength()
-{
-    return 2 * sizeof(uint32_t);
-}
-
-
-void
-FS4Packet_QUEUELEN::Encode(FNET_DataBuffer *dst)
-{
-    dst->WriteInt32Fast(_queueLen);
-    dst->WriteInt32Fast(_dispatchers);
-}
-
-
-bool
-FS4Packet_QUEUELEN::Decode(FNET_DataBuffer *src, uint32_t len)
-{
-    if (len != 2 * sizeof(uint32_t)) {
-        src->DataToDead(len);
-        return false;
-    }
-    _queueLen = src->ReadInt32();
-    _dispatchers = src->ReadInt32();
-    return true;
-}
-
-
-vespalib::string
-FS4Packet_QUEUELEN::toString(uint32_t indent) const
-{
-    vespalib::string s;
-    s += make_string("%*sFS4Packet_QUEUELEN {\n", indent, "");
-    s += make_string("%*s  queue len   : %d\n", indent, "", _queueLen);
-    s += make_string("%*s  dispatchers : %d\n", indent, "", _dispatchers);
-    s += make_string("%*s}\n", indent, "");
-    return s;
-}
-
-//============================================================
-
 void
 FS4Packet_QUERYRESULTX::AllocateSortIndex(uint32_t cnt)
 {
@@ -1089,29 +927,6 @@ FS4Packet_QUERYRESULTX::SetSortDataRef(uint32_t cnt,
 
 
 void
-FS4Packet_QUERYRESULTX::AllocateAggrData(uint32_t len)
-{
-    if (len == 0)
-        return;
-
-    _aggrData = (char *) malloc(len);
-    _aggrDataLen = len;
-}
-
-
-void
-FS4Packet_QUERYRESULTX::SetAggrDataRef(const char *aggrData,
-                                       uint32_t len)
-{
-    if (len == 0)
-        return;
-
-    AllocateAggrData(len);
-    memcpy(_aggrData, aggrData, len);
-}
-
-
-void
 FS4Packet_QUERYRESULTX::AllocateGroupData(uint32_t len)
 {
     if (len == 0)
@@ -1145,9 +960,8 @@ FS4Packet_QUERYRESULTX::AllocateHits(uint32_t cnt)
 }
 
 
-FS4Packet_QUERYRESULTX::FS4Packet_QUERYRESULTX(uint32_t pcode)
+FS4Packet_QUERYRESULTX::FS4Packet_QUERYRESULTX()
     : FS4Packet(),
-      _pcode(pcode),
       _distributionKey(0),
       _features(0),
       _offset(0),
@@ -1156,8 +970,6 @@ FS4Packet_QUERYRESULTX::FS4Packet_QUERYRESULTX(uint32_t pcode)
       _maxRank(0),
       _sortIndex(NULL),
       _sortData(NULL),
-      _aggrDataLen(0),
-      _aggrData(NULL),
       _groupDataLen(0),
       _groupData(NULL),
       _coverageDocs(0),
@@ -1165,7 +977,6 @@ FS4Packet_QUERYRESULTX::FS4Packet_QUERYRESULTX(uint32_t pcode)
       _hits(NULL),
       _propsVector()
 {
-    UpdateCompatFeatures();
 }
 
 
@@ -1173,34 +984,11 @@ FS4Packet_QUERYRESULTX::~FS4Packet_QUERYRESULTX()
 {
     if (_sortIndex) { delete [] _sortIndex; }
     if (_sortData) { free(_sortData); }
-    if (_aggrData) { free(_aggrData); }
     if (_groupData) { free(_groupData); }
     if (_hits) { delete [] _hits; }
 }
 
 
-void
-FS4Packet_QUERYRESULTX::UpdateCompatPCODE()
-{
-    if (_features == search::fs4transport::QRF_QUERYRESULT_MASK)
-        _pcode =     search::fs4transport::PCODE_QUERYRESULT;
-    else if (_features == search::fs4transport::QRF_MLD_QUERYRESULT_MASK)
-        _pcode =          search::fs4transport::PCODE_MLD_QUERYRESULT;
-    else
-        _pcode = search::fs4transport::PCODE_QUERYRESULTX;
-}
-
-
-void
-FS4Packet_QUERYRESULTX::UpdateCompatFeatures()
-{
-    if (_pcode == search::fs4transport::PCODE_QUERYRESULT)
-        _features =   search::fs4transport::QRF_QUERYRESULT_MASK;
-    else if (_pcode == search::fs4transport::PCODE_MLD_QUERYRESULT)
-        _features =        search::fs4transport::QRF_MLD_QUERYRESULT_MASK;
-}
-
-
 uint32_t
 FS4Packet_QUERYRESULTX::GetLength()
 {
@@ -1209,30 +997,21 @@ FS4Packet_QUERYRESULTX::GetLength()
                     sizeof(search::HitRank) +
                     _numDocs * (sizeof(document::GlobalId) + sizeof(search::HitRank));
 
-    if (_pcode == search::fs4transport::PCODE_QUERYRESULTX)
-        plen += sizeof(uint32_t);
+    plen += sizeof(uint32_t);
 
-    if ((_features & search::fs4transport::QRF_MLD) != 0)
+    if ((_features & QRF_MLD) != 0)
         plen += _numDocs * 2 * sizeof(uint32_t);
 
-    if (((_features & search::fs4transport::QRF_SORTDATA) != 0) &&
-        (_numDocs > 0))
-        plen += _numDocs * sizeof(uint32_t)
-                + (_sortIndex[_numDocs] - _sortIndex[0]);
-
-    if ((_features & search::fs4transport::QRF_AGGRDATA) != 0)
-        plen += sizeof(uint32_t)
-                + _aggrDataLen;
+    if (((_features & QRF_SORTDATA) != 0) && (_numDocs > 0)) 
+        plen += _numDocs * sizeof(uint32_t) + (_sortIndex[_numDocs] - _sortIndex[0]);
 
-    if ((_features & search::fs4transport::QRF_GROUPDATA) != 0)
-        plen += sizeof(uint32_t)
-                + _groupDataLen;
+    if ((_features & QRF_GROUPDATA) != 0)
+        plen += sizeof(uint32_t) + _groupDataLen;
 
-    if ((_features & search::fs4transport::QRF_COVERAGE) != 0)
-        plen += sizeof(uint64_t)
-                + 2 * sizeof(uint32_t);
+    if ((_features & QRF_COVERAGE) != 0)
+        plen += sizeof(uint64_t) + 2 * sizeof(uint32_t);
 
-    if ((_features & search::fs4transport::QRF_PROPERTIES) != 0) {
+    if ((_features & QRF_PROPERTIES) != 0) {
         plen += sizeof(uint32_t);
         for (uint32_t i = 0; i < _propsVector.size(); ++i) {
             plen += _propsVector[i].getLength();
@@ -1246,10 +1025,7 @@ FS4Packet_QUERYRESULTX::GetLength()
 void
 FS4Packet_QUERYRESULTX::Encode(FNET_DataBuffer *dst)
 {
-    if (_pcode == search::fs4transport::PCODE_QUERYRESULTX) {
-        // Never provide QF_WARMUP downwards
-        dst->WriteInt32Fast(_features & ~QF_WARMUP);
-    }
+    dst->WriteInt32Fast(_features);
     dst->WriteInt32Fast(_offset);
     dst->WriteInt32Fast(_numDocs);
     dst->WriteInt64Fast(_totNumDocs);
@@ -1258,7 +1034,7 @@ FS4Packet_QUERYRESULTX::Encode(FNET_DataBuffer *dst)
     dst->WriteInt64Fast(mrval.INT64);
     dst->WriteInt32Fast(_distributionKey);
 
-    if (((_features & search::fs4transport::QRF_SORTDATA) != 0) &&
+    if (((_features & QRF_SORTDATA) != 0) &&
         (_numDocs > 0))
     {
         uint32_t idx0 = _sortIndex[0];
@@ -1270,17 +1046,12 @@ FS4Packet_QUERYRESULTX::Encode(FNET_DataBuffer *dst)
                             _sortIndex[_numDocs] - idx0);
     }
 
-    if ((_features & search::fs4transport::QRF_AGGRDATA) != 0) {
-        dst->WriteInt32Fast(_aggrDataLen);
-        dst->WriteBytesFast(_aggrData, _aggrDataLen);
-    }
-
-    if ((_features & search::fs4transport::QRF_GROUPDATA) != 0) {
+    if ((_features & QRF_GROUPDATA) != 0) {
         dst->WriteInt32Fast(_groupDataLen);
         dst->WriteBytesFast(_groupData, _groupDataLen);
     }
 
-    if ((_features & search::fs4transport::QRF_COVERAGE) != 0) {
+    if ((_features & QRF_COVERAGE) != 0) {
         dst->WriteInt64Fast(_coverageDocs);
         dst->WriteInt64Fast(_activeDocs);
     }
@@ -1290,13 +1061,13 @@ FS4Packet_QUERYRESULTX::Encode(FNET_DataBuffer *dst)
         union { uint64_t INT64; double DOUBLE; } val;
         val.DOUBLE = _hits[i]._metric;
         dst->WriteInt64Fast(val.INT64);
-        if ((_features & search::fs4transport::QRF_MLD) != 0) {
+        if ((_features & QRF_MLD) != 0) {
             dst->WriteInt32Fast(_hits[i]._partid);
             dst->WriteInt32Fast(_hits[i].getDistributionKey());
         }
     }
 
-    if ((_features & search::fs4transport::QRF_PROPERTIES) != 0) {
+    if ((_features & QRF_PROPERTIES) != 0) {
         dst->WriteInt32Fast(_propsVector.size());
         for (uint32_t i = 0; i < _propsVector.size(); ++i) {
             _propsVector[i].encode(*dst);
@@ -1309,17 +1080,14 @@ FS4Packet_QUERYRESULTX::Encode(FNET_DataBuffer *dst)
 bool
 FS4Packet_QUERYRESULTX::Decode(FNET_DataBuffer *src, uint32_t len)
 {
-    uint32_t i;
     uint32_t hitSize = sizeof(document::GlobalId);
 
-    if (_pcode == search::fs4transport::PCODE_QUERYRESULTX) {
-        if (len < sizeof(uint32_t)) goto error;
-        _features = src->ReadInt32();
-        len -= sizeof(uint32_t);
-    }
+    if (len < sizeof(uint32_t)) goto error;
+    _features = src->ReadInt32();
+    len -= sizeof(uint32_t);
 
-    if ((_features & ~search::fs4transport::FNET_QRF_SUPPORTED_MASK) != 0) {
-        throwUnsupportedFeatures(_features, search::fs4transport::FNET_QRF_SUPPORTED_MASK);
+    if ((_features & ~FNET_QRF_SUPPORTED_MASK) != 0) {
+        throwUnsupportedFeatures(_features, FNET_QRF_SUPPORTED_MASK);
     }
     hitSize += sizeof(uint64_t);
 
@@ -1333,13 +1101,14 @@ FS4Packet_QUERYRESULTX::Decode(FNET_DataBuffer *src, uint32_t len)
     _distributionKey   = src->ReadInt32();
     len -= 3 * sizeof(uint32_t) + sizeof(uint64_t) + sizeof(search::HitRank);
 
-    if (((_features & search::fs4transport::QRF_SORTDATA) != 0) &&
+    if (((_features & QRF_SORTDATA) != 0) &&
         (_numDocs > 0)) {
         if (len < _numDocs * sizeof(uint32_t)) goto error;
         AllocateSortIndex(_numDocs);
         _sortIndex[0] = 0; // implicit
-        for (i = 1; i <= _numDocs; i++)
+        for (uint32_t i = 1; i <= _numDocs; i++) {
             _sortIndex[i] = src->ReadInt32();
+        }
         len -= _numDocs * sizeof(uint32_t);
         uint32_t sortDataLen = _sortIndex[_numDocs];
 
@@ -1349,18 +1118,7 @@ FS4Packet_QUERYRESULTX::Decode(FNET_DataBuffer *src, uint32_t len)
         len -= sortDataLen;
     }
 
-    if ((_features & search::fs4transport::QRF_AGGRDATA) != 0) {
-        if (len < sizeof(uint32_t)) goto error;
-        _aggrDataLen = src->ReadInt32();
-        len -= sizeof(uint32_t);
-
-        if (len < _aggrDataLen) goto error;
-        AllocateAggrData(_aggrDataLen);
-        src->ReadBytes(_aggrData, _aggrDataLen);
-        len -= _aggrDataLen;
-    }
-
-    if ((_features & search::fs4transport::QRF_GROUPDATA) != 0) {
+    if ((_features & QRF_GROUPDATA) != 0) {
         if (len < sizeof(uint32_t)) goto error;
         _groupDataLen = src->ReadInt32();
         len -= sizeof(uint32_t);
@@ -1371,26 +1129,26 @@ FS4Packet_QUERYRESULTX::Decode(FNET_DataBuffer *src, uint32_t len)
         len -= _groupDataLen;
     }
 
-    if ((_features & search::fs4transport::QRF_COVERAGE) != 0) {
+    if ((_features & QRF_COVERAGE) != 0) {
         if (len < 2 * sizeof(uint64_t)) goto error;
         _coverageDocs  = src->ReadInt64();
         _activeDocs = src->ReadInt64();
         len -= 2 * sizeof(uint64_t);
     }
 
-    if ((_features & search::fs4transport::QRF_MLD) != 0)
+    if ((_features & QRF_MLD) != 0)
         hitSize += 2 * sizeof(uint32_t);
 
     if (len < _numDocs * hitSize) goto error;
     AllocateHits(_numDocs);
     unsigned char rawGid[document::GlobalId::LENGTH];
-    for (i = 0; i < _numDocs; i++) {
+    for (uint32_t i = 0; i < _numDocs; i++) {
         src->ReadBytes(rawGid, document::GlobalId::LENGTH);
         _hits[i]._gid.set(rawGid);
         union { uint64_t INT64; double DOUBLE; } val;
         val.INT64 = src->ReadInt64();
         _hits[i]._metric = val.DOUBLE;
-        if ((_features & search::fs4transport::QRF_MLD) != 0) {
+        if ((_features & QRF_MLD) != 0) {
             _hits[i]._partid   = src->ReadInt32();
             _hits[i].setDistributionKey(src->ReadInt32());
         } else {
@@ -1400,18 +1158,17 @@ FS4Packet_QUERYRESULTX::Decode(FNET_DataBuffer *src, uint32_t len)
     }
     len -= _numDocs * hitSize;
 
-    if ((_features & search::fs4transport::QRF_PROPERTIES) != 0) {
+    if ((_features & QRF_PROPERTIES) != 0) {
         uint32_t sz = src->ReadInt32();
         _propsVector.resize(sz);
         len -= sizeof(uint32_t);
-        for (i = 0; i < sz; ++i) {
+        for (uint32_t i = 0; i < sz; ++i) {
             if (! _propsVector[i].decode(*src, len)) goto error;
         }
     }
 
     if (len != 0) goto error;
 
-    SetRealPCODE();
     return true;            // OK
 
  error:
@@ -1427,7 +1184,6 @@ FS4Packet_QUERYRESULTX::toString(uint32_t indent) const
     uint32_t i;
 
     s += make_string("%*sFS4Packet_QUERYRESULTX {\n", indent, "");
-    s += make_string("%*s  pcode         : %d\n", indent, "", _pcode);
     s += make_string("%*s  features      : 0x%x\n", indent, "", _features);
     s += make_string("%*s  offset        : %d\n", indent, "", _offset);
     s += make_string("%*s  numDocs       : %d\n", indent, "", _numDocs);
@@ -1444,7 +1200,6 @@ FS4Packet_QUERYRESULTX::toString(uint32_t indent) const
             s += make_string(" }\n");
         }
     }
-    s += make_string("%*s  aggrData      : %d bytes\n", indent, "", _aggrDataLen);
     s += make_string("%*s  groupData     : %d bytes\n", indent, "", _groupDataLen);
     s += make_string("%*s  coverageDocs  : %" PRIu64 "\n", indent, "", _coverageDocs);
     s += make_string("%*s  activeDocs    : %" PRIu64 "\n", indent, "", _activeDocs);
@@ -1462,9 +1217,8 @@ FS4Packet_QUERYRESULTX::toString(uint32_t indent) const
 //============================================================
 
 
-FS4Packet_QUERYX::FS4Packet_QUERYX(uint32_t pcode)
+FS4Packet_QUERYX::FS4Packet_QUERYX()
     : FS4Packet(),
-      _pcode(pcode),
       _timeout(0),
       _features(0),
       _offset(0),
@@ -1473,14 +1227,12 @@ FS4Packet_QUERYX::FS4Packet_QUERYX(uint32_t pcode)
       _ranking(),
       _propsVector(),
       _sortSpec(),
-      _aggrSpec(),
       _groupSpec(),
       _sessionId(),
       _location(),
       _numStackItems(0),
       _stackDump()
 {
-    UpdateCompatFeatures();
 }
 
 
@@ -1488,68 +1240,40 @@ FS4Packet_QUERYX::~FS4Packet_QUERYX()
 {
 }
 
-
-void
-FS4Packet_QUERYX::UpdateCompatPCODE()
-{
-    if (_features == search::fs4transport::QF_PARSEDQUERY2_MASK)
-        _pcode =         search::fs4transport::PCODE_PARSEDQUERY2;
-    else
-        _pcode = search::fs4transport::PCODE_QUERYX;
-}
-
-
-void
-FS4Packet_QUERYX::UpdateCompatFeatures()
-{
-    if (_pcode == search::fs4transport::PCODE_PARSEDQUERY2)
-        _features =         search::fs4transport::QF_PARSEDQUERY2_MASK;
-}
-
-
 uint32_t
 FS4Packet_QUERYX::GetLength()
 {
     uint32_t plen = 2 * sizeof(uint32_t);
     plen += FNET_DataBuffer::getCompressedPositiveLength(_offset);
     plen += FNET_DataBuffer::getCompressedPositiveLength(_maxhits);
-    if (_pcode == search::fs4transport::PCODE_QUERYX)
-        plen += sizeof(uint32_t);
+    plen += sizeof(uint32_t);
 
-    if ((_features & search::fs4transport::QF_PARSEDQUERY) != 0) {
+    if ((_features & QF_PARSEDQUERY) != 0) {
         plen += sizeof(uint32_t)*2;
         plen += _stackDump.size();
     }
-    if ((_features & search::fs4transport::QF_RANKP) != 0) {
+    if ((_features & QF_RANKP) != 0) {
         plen += FNET_DataBuffer::getCompressedPositiveLength(_ranking.size());
         plen += _ranking.size();
     }
-    if ((_features & search::fs4transport::QF_PROPERTIES) != 0) {
+    if ((_features & QF_PROPERTIES) != 0) {
         plen += sizeof(uint32_t);
         for (uint32_t i = 0; i < _propsVector.size(); ++i) {
             plen += _propsVector[i].getLength();
         }
     }
 
-    if ((_features & search::fs4transport::QF_SORTSPEC) != 0)
-        plen += sizeof(uint32_t)
-                + _sortSpec.size();
+    if ((_features & QF_SORTSPEC) != 0)
+        plen += sizeof(uint32_t) + _sortSpec.size();
 
-    if ((_features & search::fs4transport::QF_AGGRSPEC) != 0)
-        plen += sizeof(uint32_t)
-                + _aggrSpec.size();
+    if ((_features & QF_GROUPSPEC) != 0)
+        plen += sizeof(uint32_t) + _groupSpec.size();
 
-    if ((_features & search::fs4transport::QF_GROUPSPEC) != 0)
-        plen += sizeof(uint32_t)
-                + _groupSpec.size();
+    if ((_features & QF_SESSIONID) != 0)
+        plen += sizeof(uint32_t) + _sessionId.size();
 
-    if ((_features & search::fs4transport::QF_SESSIONID) != 0)
-        plen += sizeof(uint32_t)
-                + _sessionId.size();
-
-    if ((_features & search::fs4transport::QF_LOCATION) != 0)
-        plen += sizeof(uint32_t)
-                + _location.size();
+    if ((_features & QF_LOCATION) != 0)
+        plen += sizeof(uint32_t) + _location.size();
 
     return plen;
 }
@@ -1558,52 +1282,46 @@ FS4Packet_QUERYX::GetLength()
 void
 FS4Packet_QUERYX::Encode(FNET_DataBuffer *dst)
 {
-    if (_pcode == search::fs4transport::PCODE_QUERYX)
-        dst->WriteInt32Fast(_features);
+    dst->WriteInt32Fast(_features);
 
     dst->writeCompressedPositive(_offset);
     dst->writeCompressedPositive(_maxhits);
     dst->WriteInt32Fast(_timeout);
     dst->WriteInt32Fast(_qflags);
 
-    if ((_features & search::fs4transport::QF_RANKP) != 0) {
+    if ((_features & QF_RANKP) != 0) {
         dst->writeCompressedPositive(_ranking.size());
         dst->WriteBytesFast(_ranking.c_str(), _ranking.size());
     }
 
-    if ((_features & search::fs4transport::QF_PROPERTIES) != 0) {
+    if ((_features & QF_PROPERTIES) != 0) {
         dst->WriteInt32Fast(_propsVector.size());
         for (uint32_t i = 0; i < _propsVector.size(); ++i) {
             _propsVector[i].encode(*dst);
         }
     }
 
-    if ((_features & search::fs4transport::QF_SORTSPEC) != 0) {
+    if ((_features & QF_SORTSPEC) != 0) {
         dst->WriteInt32Fast(_sortSpec.size());
         dst->WriteBytesFast(_sortSpec.c_str(), _sortSpec.size());
     }
 
-    if ((_features & search::fs4transport::QF_AGGRSPEC) != 0) {
-        dst->WriteInt32Fast(_aggrSpec.size());
-        dst->WriteBytesFast(_aggrSpec.c_str(), _aggrSpec.size());
-    }
-
-    if ((_features & search::fs4transport::QF_GROUPSPEC) != 0) {
+    if ((_features & QF_GROUPSPEC) != 0) {
         dst->WriteInt32Fast(_groupSpec.size());
         dst->WriteBytesFast(_groupSpec.c_str(), _groupSpec.size());
     }
 
-    if ((_features & search::fs4transport::QF_SESSIONID) != 0) {
+    if ((_features & QF_SESSIONID) != 0) {
         dst->WriteInt32Fast(_sessionId.size());
         dst->WriteBytesFast(_sessionId.c_str(), _sessionId.size());
     }
 
-    if ((_features & search::fs4transport::QF_LOCATION) != 0) {
+    if ((_features & QF_LOCATION) != 0) {
         dst->WriteInt32Fast(_location.size());
         dst->WriteBytesFast(_location.c_str(), _location.size());
     }
 
-    if ((_features & search::fs4transport::QF_PARSEDQUERY) != 0) {
+    if ((_features & QF_PARSEDQUERY) != 0) {
         dst->WriteInt32Fast(_numStackItems);
         dst->WriteInt32Fast(_stackDump.size());
         dst->WriteBytesFast(_stackDump.c_str(), _stackDump.size());
@@ -1670,12 +1388,10 @@ FS4Packet_QUERYX::getTimeout() const
 bool
 FS4Packet_QUERYX::Decode(FNET_DataBuffer *src, uint32_t len)
 {
-    if (_pcode == search::fs4transport::PCODE_QUERYX) {
-        _features = readUInt32(*src, len, "features");
-    }
+    _features = readUInt32(*src, len, "features");
 
-    if (((_features & ~search::fs4transport::FNET_QF_SUPPORTED_MASK) != 0)) {
-        throwUnsupportedFeatures(_features, search::fs4transport::FNET_QF_SUPPORTED_MASK);
+    if (((_features & ~FNET_QF_SUPPORTED_MASK) != 0)) {
+        throwUnsupportedFeatures(_features, FNET_QF_SUPPORTED_MASK);
     }
     _offset  = src->readCompressedPositiveInteger();
     len -= FNET_DataBuffer::getCompressedPositiveLength(_offset);
@@ -1685,7 +1401,7 @@ FS4Packet_QUERYX::Decode(FNET_DataBuffer *src, uint32_t len)
     _timeout = src->ReadInt32();
     _qflags  = src->ReadInt32();
 
-    if ((_features & search::fs4transport::QF_RANKP) != 0) {
+    if ((_features & QF_RANKP) != 0) {
         uint32_t rankingLen = src->readCompressedPositiveInteger();
         len -= FNET_DataBuffer::getCompressedPositiveLength(rankingLen);
         VERIFY_LEN(rankingLen, "ranking blob");
@@ -1693,7 +1409,7 @@ FS4Packet_QUERYX::Decode(FNET_DataBuffer *src, uint32_t len)
         src->DataToDead(rankingLen);
     }
 
-    if ((_features & search::fs4transport::QF_PROPERTIES) != 0) {
+    if ((_features & QF_PROPERTIES) != 0) {
         uint32_t cnt = readUInt32(*src, len, "#properties");
         _propsVector.resize(cnt);
         for (uint32_t i = 0; i < cnt; ++i) {
@@ -1703,7 +1419,7 @@ FS4Packet_QUERYX::Decode(FNET_DataBuffer *src, uint32_t len)
         }
     }
 
-    if ((_features & search::fs4transport::QF_SORTSPEC) != 0) {
+    if ((_features & QF_SORTSPEC) != 0) {
         uint32_t sortSpecLen = readUInt32(*src, len, "sortspec length");
 
         VERIFY_LEN(sortSpecLen, "sortspec string");
@@ -1711,15 +1427,7 @@ FS4Packet_QUERYX::Decode(FNET_DataBuffer *src, uint32_t len)
         src->DataToDead(sortSpecLen);
     }
 
-    if ((_features & search::fs4transport::QF_AGGRSPEC) != 0) {
-        uint32_t aggrSpecLen = readUInt32(*src, len, "aggrspec length");
-
-        VERIFY_LEN(aggrSpecLen, "aggrspec string");
-        setAggrSpec(stringref(src->GetData(), aggrSpecLen));
-        src->DataToDead(aggrSpecLen);
-    }
-
-    if ((_features & search::fs4transport::QF_GROUPSPEC) != 0) {
+    if ((_features & QF_GROUPSPEC) != 0) {
         uint32_t groupSpecLen = readUInt32(*src, len, "groupspec length");
 
         VERIFY_LEN(groupSpecLen, "groupspec string");
@@ -1727,14 +1435,14 @@ FS4Packet_QUERYX::Decode(FNET_DataBuffer *src, uint32_t len)
         src->DataToDead(groupSpecLen);
     }
 
-    if ((_features & search::fs4transport::QF_SESSIONID) != 0) {
+    if ((_features & QF_SESSIONID) != 0) {
         uint32_t sessionIdLen = readUInt32(*src, len, "sessionid length");
         VERIFY_LEN(sessionIdLen, "sessionid string");
         setSessionId(stringref(src->GetData(), sessionIdLen));
         src->DataToDead(sessionIdLen);
     }
 
-    if ((_features & search::fs4transport::QF_LOCATION) != 0) {
+    if ((_features & QF_LOCATION) != 0) {
         uint32_t locationLen = readUInt32(*src, len, "location length");
 
         VERIFY_LEN(locationLen, "location string");
@@ -1742,11 +1450,7 @@ FS4Packet_QUERYX::Decode(FNET_DataBuffer *src, uint32_t len)
         src->DataToDead(locationLen);
     }
 
-    if ((_features & search::fs4transport::QF_WARMUP) != 0) {
-        (void) readUInt32(*src, len, "warmup");
-    }
-
-    if ((_features & search::fs4transport::QF_PARSEDQUERY) != 0) {
+    if ((_features & QF_PARSEDQUERY) != 0) {
         _numStackItems = readUInt32(*src, len, "# querystack items");
 
         uint32_t stackDumpLen = readUInt32(*src, len, "stackdump length");
@@ -1758,8 +1462,7 @@ FS4Packet_QUERYX::Decode(FNET_DataBuffer *src, uint32_t len)
         throwNotEnoughData(*src, len, 0, "eof");
     }
 
-    SetRealPCODE();
-    return true;            // OK
+    return true;
 }
 
 
@@ -1768,7 +1471,6 @@ FS4Packet_QUERYX::toString(uint32_t indent) const
 {
     vespalib::string s;
     s += make_string("%*sFS4Packet_QUERYX {\n", indent, "");
-    s += make_string("%*s  pcode       : %d\n", indent, "", _pcode);
     s += make_string("%*s  features    : 0x%x\n", indent, "", _features);
     s += make_string("%*s  offset      : %d\n", indent, "", _offset);
     s += make_string("%*s  maxhits     : %d\n", indent, "", _maxhits);
@@ -1778,7 +1480,6 @@ FS4Packet_QUERYX::toString(uint32_t indent) const
         s += _propsVector[i].toString(indent + 2);
     }
     s += make_string("%*s  sortspec    : %s\n", indent, "", _sortSpec.c_str());
-    s += make_string("%*s  aggrspec    : %s\n", indent, "", _aggrSpec.c_str());
     s += make_string("%*s  groupspec   : (%d bytes)\n", indent, "", (int)_groupSpec.size());
     s += make_string("%*s  sessionId   : (%d bytes)\n", indent, "", (int)_sessionId.size());
     s += make_string("%*s  location    : %s\n", indent, "", _location.c_str());
@@ -1810,14 +1511,12 @@ FS4Packet_GETDOCSUMSX::AllocateDocIDs(uint32_t cnt)
     if (cnt == 0)
         return;
 
-    _docid = new FS4_docid[cnt];
-    _docidCnt = cnt;
+    _docid.resize(cnt);
 }
 
 
-FS4Packet_GETDOCSUMSX::FS4Packet_GETDOCSUMSX(uint32_t pcode)
+FS4Packet_GETDOCSUMSX::FS4Packet_GETDOCSUMSX()
     : FS4Packet(),
-      _pcode(pcode),
       _timeout(0),
       _features(0),
       _ranking(),
@@ -1828,77 +1527,49 @@ FS4Packet_GETDOCSUMSX::FS4Packet_GETDOCSUMSX(uint32_t pcode)
       _stackDump(),
       _location(),
       _flags(0u),
-      _docid(NULL),
-      _docidCnt(0)
+      _docid()
 {
-    UpdateCompatFeatures();
 }
 
 
 FS4Packet_GETDOCSUMSX::~FS4Packet_GETDOCSUMSX()
 {
-    delete [] _docid;
-}
-
-
-void
-FS4Packet_GETDOCSUMSX::UpdateCompatPCODE()
-{
-    if (_features == search::fs4transport::GDF_GETDOCSUMS_MASK)
-        _pcode     = search::fs4transport::PCODE_GETDOCSUMS;
-    else if (_features == search::fs4transport::GDF_MLD_GETDOCSUMS_MASK)
-        _pcode          = search::fs4transport::PCODE_MLD_GETDOCSUMS;
-    else
-        _pcode = search::fs4transport::PCODE_GETDOCSUMSX;
-}
-
-
-void
-FS4Packet_GETDOCSUMSX::UpdateCompatFeatures()
-{
-    if (_pcode == search::fs4transport::PCODE_GETDOCSUMS)
-        _features   = search::fs4transport::GDF_GETDOCSUMS_MASK;
-    else if (_pcode == search::fs4transport::PCODE_MLD_GETDOCSUMS)
-        _features        = search::fs4transport::GDF_MLD_GETDOCSUMS_MASK;
 }
 
-
 uint32_t
 FS4Packet_GETDOCSUMSX::GetLength()
 {
     uint32_t plen = 2 * sizeof(uint32_t) +
-        + _docidCnt * (sizeof(document::GlobalId));
+        + _docid.size() * (sizeof(document::GlobalId));
 
-    if (_pcode == search::fs4transport::PCODE_GETDOCSUMSX)
-        plen += sizeof(uint32_t);
+    plen += sizeof(uint32_t);
 
-    if ((_features & search::fs4transport::GDF_MLD) != 0)
-        plen += 2 * _docidCnt * sizeof(uint32_t);
+    if ((_features & GDF_MLD) != 0)
+        plen += 2 * _docid.size() * sizeof(uint32_t);
 
-    if ((_features & search::fs4transport::GDF_QUERYSTACK) != 0)
+    if ((_features & GDF_QUERYSTACK) != 0)
         plen += 2 * sizeof(uint32_t) + _stackDump.size();
 
-    if ((_features & search::fs4transport::GDF_RESCLASSNAME) != 0)
+    if ((_features & GDF_RESCLASSNAME) != 0)
         plen += sizeof(uint32_t) + _resultClassName.size();
 
-    if ((_features & search::fs4transport::GDF_PROPERTIES) != 0) {
+    if ((_features & GDF_PROPERTIES) != 0) {
         plen += sizeof(uint32_t);
         for (uint32_t i = 0; i < _propsVector.size(); ++i) {
             plen += _propsVector[i].getLength();
         }
     }
 
-    if ((_features & search::fs4transport::GDF_RANKP_QFLAGS) != 0) {
+    if ((_features & GDF_RANKP_QFLAGS) != 0) {
         plen += FNET_DataBuffer::getCompressedPositiveLength(_ranking.size());
         plen += _ranking.size();
         plen += sizeof(uint32_t);
     }
 
-    if ((_features & search::fs4transport::GDF_LOCATION) != 0)
-        plen += sizeof(uint32_t)
-                + _location.size();
+    if ((_features & GDF_LOCATION) != 0)
+        plen += sizeof(uint32_t) + _location.size();
 
-    if ((_features & search::fs4transport::GDF_FLAGS) != 0)
+    if ((_features & GDF_FLAGS) != 0)
         plen += sizeof(uint32_t);
 
     return plen;
@@ -1908,47 +1579,46 @@ FS4Packet_GETDOCSUMSX::GetLength()
 void
 FS4Packet_GETDOCSUMSX::Encode(FNET_DataBuffer *dst)
 {
-    if (_pcode == search::fs4transport::PCODE_GETDOCSUMSX)
-        dst->WriteInt32Fast(_features);
+    dst->WriteInt32Fast(_features);
 
     dst->WriteInt32Fast(0);
     dst->WriteInt32Fast(_timeout);
 
-    if ((_features & search::fs4transport::GDF_RANKP_QFLAGS) != 0) {
+    if ((_features & GDF_RANKP_QFLAGS) != 0) {
         dst->writeCompressedPositive(_ranking.size());
         dst->WriteBytesFast(_ranking.c_str(), _ranking.size());
         dst->WriteInt32Fast(_qflags);
     }
 
-    if ((_features & search::fs4transport::GDF_RESCLASSNAME) != 0) {
+    if ((_features & GDF_RESCLASSNAME) != 0) {
         writeLenString(dst, _resultClassName);
     }
 
-    if ((_features & search::fs4transport::GDF_PROPERTIES) != 0) {
+    if ((_features & GDF_PROPERTIES) != 0) {
         dst->WriteInt32Fast(_propsVector.size());
         for (uint32_t i = 0; i < _propsVector.size(); ++i) {
             _propsVector[i].encode(*dst);
         }
     }
 
-    if ((_features & search::fs4transport::GDF_QUERYSTACK) != 0) {
+    if ((_features & GDF_QUERYSTACK) != 0) {
         dst->WriteInt32Fast(_stackItems);
         writeLenString(dst, _stackDump);
     }
 
-    if ((_features & search::fs4transport::GDF_LOCATION) != 0) {
+    if ((_features & GDF_LOCATION) != 0) {
         writeLenString(dst, _location);
     }
 
-    if ((_features & search::fs4transport::GDF_FLAGS) != 0) {
+    if ((_features & GDF_FLAGS) != 0) {
         dst->WriteInt32Fast(_flags);
     }
 
-    for (uint32_t i = 0; i < _docidCnt; i++) {
-        dst->WriteBytesFast(_docid[i]._gid.get(), document::GlobalId::LENGTH);
+    for (const auto & docid : _docid) {
+        dst->WriteBytesFast(docid._gid.get(), document::GlobalId::LENGTH);
 
-        if ((_features & search::fs4transport::GDF_MLD) != 0) {
-            dst->WriteInt32Fast(_docid[i]._partid);
+        if ((_features & GDF_MLD) != 0) {
+            dst->WriteInt32Fast(docid._partid);
             dst->WriteInt32Fast(0);
         }
     }
@@ -1960,19 +1630,17 @@ FS4Packet_GETDOCSUMSX::Decode(FNET_DataBuffer *src, uint32_t len)
 {
     uint32_t docidSize = sizeof(document::GlobalId);
 
-    if (_pcode == search::fs4transport::PCODE_GETDOCSUMSX) {
-        _features = readUInt32(*src, len, "features");
-    }
+    _features = readUInt32(*src, len, "features");
 
-    if ((_features & ~search::fs4transport::FNET_GDF_SUPPORTED_MASK) != 0) {
-        throwUnsupportedFeatures(_features, search::fs4transport::FNET_GDF_SUPPORTED_MASK);
+    if ((_features & ~FNET_GDF_SUPPORTED_MASK) != 0) {
+        throwUnsupportedFeatures(_features, FNET_GDF_SUPPORTED_MASK);
     }
 
     VERIFY_LEN(2*sizeof(uint32_t), "unused and timeout");
     src->ReadInt32();  // unused
     _timeout = src->ReadInt32();
 
-    if ((_features & search::fs4transport::GDF_RANKP_QFLAGS) != 0) {
+    if ((_features & GDF_RANKP_QFLAGS) != 0) {
         uint32_t rankingLen = src->readCompressedPositiveInteger();
         len -= FNET_DataBuffer::getCompressedPositiveLength(rankingLen);
 
@@ -1983,7 +1651,7 @@ FS4Packet_GETDOCSUMSX::Decode(FNET_DataBuffer *src, uint32_t len)
         _qflags = readUInt32(*src, len, "qflags");
     }
 
-    if ((_features & search::fs4transport::GDF_RESCLASSNAME) != 0) {
+    if ((_features & GDF_RESCLASSNAME) != 0) {
         uint32_t resultClassNameLen = readUInt32(*src, len, "result class name length");
 
         VERIFY_LEN(resultClassNameLen, "result class");
@@ -1991,7 +1659,7 @@ FS4Packet_GETDOCSUMSX::Decode(FNET_DataBuffer *src, uint32_t len)
         src->DataToDead(resultClassNameLen);
     }
 
-    if ((_features & search::fs4transport::GDF_PROPERTIES) != 0) {
+    if ((_features & GDF_PROPERTIES) != 0) {
         uint32_t cnt = readUInt32(*src, len, "#properties");
         _propsVector.resize(cnt);
         for (uint32_t i = 0; i < cnt; ++i) {
@@ -2001,7 +1669,7 @@ FS4Packet_GETDOCSUMSX::Decode(FNET_DataBuffer *src, uint32_t len)
         }
     }
 
-    if ((_features & search::fs4transport::GDF_QUERYSTACK) != 0) {
+    if ((_features & GDF_QUERYSTACK) != 0) {
         _stackItems = readUInt32(*src, len, "num stack items");
         uint32_t stackDumpLen = readUInt32(*src, len, "stackdump length");
         VERIFY_LEN(stackDumpLen, "stackdump");
@@ -2009,42 +1677,40 @@ FS4Packet_GETDOCSUMSX::Decode(FNET_DataBuffer *src, uint32_t len)
         src->DataToDead(stackDumpLen);
     }
 
-    if ((_features & search::fs4transport::GDF_LOCATION) != 0) {
+    if ((_features & GDF_LOCATION) != 0) {
         uint32_t locationLen = readUInt32(*src, len, "location length");
         VERIFY_LEN(locationLen, "location string");
         setLocation(stringref(src->GetData(), locationLen));
         src->DataToDead(locationLen);
     }
 
-    if ((_features & search::fs4transport::GDF_FLAGS) != 0) {
+    if ((_features & GDF_FLAGS) != 0) {
         _flags = readUInt32(*src, len, "flags");
     }
 
-    if ((_features & search::fs4transport::GDF_MLD) != 0)
+    if ((_features & GDF_MLD) != 0)
         docidSize += 2 * sizeof(uint32_t);
 
-    _docidCnt = len / docidSize;
-    AllocateDocIDs(_docidCnt);
+    AllocateDocIDs(len / docidSize);
 
     unsigned char rawGid[document::GlobalId::LENGTH];
-    for (uint32_t i = 0; i < _docidCnt; i++) {
+    for (auto & docid : _docid) {
         src->ReadBytes(rawGid, document::GlobalId::LENGTH);
-        _docid[i]._gid.set(rawGid);
+        docid._gid.set(rawGid);
 
-        if ((_features & search::fs4transport::GDF_MLD) != 0) {
-            _docid[i]._partid   = src->ReadInt32();
+        if ((_features & GDF_MLD) != 0) {
+            docid._partid   = src->ReadInt32();
             src->ReadInt32();  // unused
         } else {
-            _docid[i]._partid   = 0; // partid not available
+            docid._partid   = 0; // partid not available
         }
     }
-    len -= _docidCnt * docidSize;
+    len -= _docid.size() * docidSize;
 
     if (len != 0) {
         throwNotEnoughData(*src, len, 0, "eof");
     }
 
-    SetRealPCODE();
     return true;            // OK
 }
 
@@ -2076,9 +1742,9 @@ FS4Packet_GETDOCSUMSX::toString(uint32_t indent) const
         }
         if ((i % 16) != 0) s += make_string("\n");
     }
-    for (i = 0; i < _docidCnt; i++) {
+    for (const auto & docId : _docid) {
         s += make_string("%*s  gid=%s, partid=%d\n", indent, "",
-                         _docid[i]._gid.toString().c_str(), _docid[i]._partid);
+                         docId._gid.toString().c_str(), docId._partid);
     }
     s += make_string("%*s  location       : %s\n", indent, "", _location.c_str());
     s += make_string("%*s  timeout        : %d\n", indent, "", _timeout);
@@ -2144,50 +1810,23 @@ FNET_Packet*
 FS4PacketFactory::CreateFS4Packet(uint32_t pcode)
 {
     switch(pcode) {
-    case search::fs4transport::PCODE_EOL:
+    case PCODE_EOL:
         return new FS4Packet_EOL;
-    case search::fs4transport::PCODE_QUERYRESULT:
-        return new FS4Packet_QUERYRESULTX(search::fs4transport::
-                                          PCODE_QUERYRESULT);
-    case search::fs4transport::PCODE_ERROR:
+    case PCODE_ERROR:
         return new FS4Packet_ERROR;
-    case search::fs4transport::PCODE_GETDOCSUMS:
-        return new FS4Packet_GETDOCSUMSX(search::fs4transport::
-                                         PCODE_GETDOCSUMS);
-    case search::fs4transport::PCODE_DOCSUM:
+    case PCODE_DOCSUM:
         return new FS4Packet_DOCSUM;
-    case search::fs4transport::PCODE_MONITORQUERY:
-        return new FS4Packet_MONITORQUERYX(search::fs4transport::
-                                           PCODE_MONITORQUERY);
-    case search::fs4transport::PCODE_MONITORRESULT:
-        return new FS4Packet_MONITORRESULTX(search::fs4transport::
-                                            PCODE_MONITORRESULT);
-    case search::fs4transport::PCODE_MLD_QUERYRESULT:
-        return new FS4Packet_QUERYRESULTX(search::fs4transport::
-                                          PCODE_MLD_QUERYRESULT);
-    case search::fs4transport::PCODE_MLD_GETDOCSUMS:
-        return new FS4Packet_GETDOCSUMSX(search::fs4transport::
-                                         PCODE_MLD_GETDOCSUMS);
-    case search::fs4transport::PCODE_MLD_MONITORRESULT:
-        return new FS4Packet_MONITORRESULTX(search::fs4transport::
-                                            PCODE_MLD_MONITORRESULT);
-    case search::fs4transport::PCODE_CLEARCACHES:
-        return new FS4Packet_CLEARCACHES;
-    case search::fs4transport::PCODE_PARSEDQUERY2:
-        return new FS4Packet_QUERYX(search::fs4transport::PCODE_PARSEDQUERY2);
-    case search::fs4transport::PCODE_QUEUELEN:
-        return new FS4Packet_QUEUELEN;
-    case search::fs4transport::PCODE_QUERYRESULTX:
+    case PCODE_QUERYRESULTX:
         return new FS4Packet_QUERYRESULTX;
-    case search::fs4transport::PCODE_QUERYX:
+    case PCODE_QUERYX:
         return new FS4Packet_QUERYX;
-    case search::fs4transport::PCODE_GETDOCSUMSX:
+    case PCODE_GETDOCSUMSX:
         return new FS4Packet_GETDOCSUMSX;
-    case search::fs4transport::PCODE_MONITORQUERYX:
+    case PCODE_MONITORQUERYX:
         return new FS4Packet_MONITORQUERYX;
-    case search::fs4transport::PCODE_MONITORRESULTX:
+    case PCODE_MONITORRESULTX:
         return new FS4Packet_MONITORRESULTX;
-    case search::fs4transport::PCODE_TRACEREPLY:
+    case PCODE_TRACEREPLY:
         return new FS4Packet_TRACEREPLY;
     default:
         return NULL;
diff --git a/searchlib/src/vespa/searchlib/common/packets.h b/searchlib/src/vespa/searchlib/common/packets.h
index f3ea8e5b225..53cc4aa5f67 100644
--- a/searchlib/src/vespa/searchlib/common/packets.h
+++ b/searchlib/src/vespa/searchlib/common/packets.h
@@ -21,7 +21,6 @@ using vespalib::string;
 enum fnet_feature_masks {
     FNET_QRF_SUPPORTED_MASK = (QRF_MLD |
                                QRF_SORTDATA |
-                               QRF_AGGRDATA |
                                QRF_COVERAGE |
                                QRF_GROUPDATA |
                                QRF_PROPERTIES),
@@ -29,7 +28,6 @@ enum fnet_feature_masks {
     FNET_QF_SUPPORTED_MASK  = (QF_PARSEDQUERY |
                                QF_RANKP |
                                QF_SORTSPEC |
-                               QF_AGGRSPEC |
                                QF_LOCATION |
                                QF_PROPERTIES |
                                QF_GROUPSPEC |
@@ -321,17 +319,13 @@ class FS4Packet_MONITORQUERYX : public FS4Packet
     FS4Packet_MONITORQUERYX(const FS4Packet_MONITORQUERYX &);
     FS4Packet_MONITORQUERYX& operator=(const FS4Packet_MONITORQUERYX &);
 
-    uint32_t _pcode;
 public:
     uint32_t _features;         // see monitorquery_features
     uint32_t _qflags;           // if MQF_QFLAGS
 
-    FS4Packet_MONITORQUERYX(uint32_t pcode = PCODE_MONITORQUERYX);
+    FS4Packet_MONITORQUERYX();
     ~FS4Packet_MONITORQUERYX();
-    void UpdateCompatPCODE();
-    void UpdateCompatFeatures();
-    void SetRealPCODE(void) { _pcode = PCODE_MONITORQUERYX; }
-    uint32_t GetPCODE() override { return _pcode; }
+    uint32_t GetPCODE() override { return PCODE_MONITORQUERYX; }
     uint32_t GetLength() override;
     void Encode(FNET_DataBuffer *dst) override;
     bool Decode(FNET_DataBuffer *src, uint32_t len) override;
@@ -346,7 +340,6 @@ private:
     FS4Packet_MONITORRESULTX(const FS4Packet_MONITORRESULTX &);
     FS4Packet_MONITORRESULTX& operator=(const FS4Packet_MONITORRESULTX &);
 
-    uint32_t _pcode;
 public:
     uint32_t _features;         // see monitor
     uint32_t _partid;
@@ -360,43 +353,9 @@ public:
     uint32_t _rflags;           // if MRF_RFLAGS
     uint64_t _activeDocs;       // if MRF_ACTIVEDOCS
 
-    FS4Packet_MONITORRESULTX(uint32_t pcode = PCODE_MONITORRESULTX);
+    FS4Packet_MONITORRESULTX();
     ~FS4Packet_MONITORRESULTX();
-    void UpdateCompatPCODE();
-    void UpdateCompatFeatures();
-    void SetRealPCODE(void) { _pcode = PCODE_MONITORRESULTX; }
-    uint32_t GetPCODE()  override { return _pcode; }
-    uint32_t GetLength() override;
-    void Encode(FNET_DataBuffer *dst) override;
-    bool Decode(FNET_DataBuffer *src, uint32_t len) override;
-    vespalib::string toString(uint32_t indent) const override;
-};
-
-//==========================================================================
-
-class FS4Packet_CLEARCACHES : public FS4Packet
-{
-public:
-    FS4Packet_CLEARCACHES();
-    ~FS4Packet_CLEARCACHES();
-    uint32_t GetPCODE() override { return PCODE_CLEARCACHES; }
-    uint32_t GetLength() override;
-    void Encode(FNET_DataBuffer *dst) override;
-    bool Decode(FNET_DataBuffer *src, uint32_t len) override;
-    vespalib::string toString(uint32_t indent) const override;
-};
-
-//==========================================================================
-
-class FS4Packet_QUEUELEN : public FS4Packet
-{
-public:
-    uint32_t _queueLen;
-    uint32_t _dispatchers;
-
-    FS4Packet_QUEUELEN();
-    ~FS4Packet_QUEUELEN();
-    uint32_t GetPCODE() override { return PCODE_QUEUELEN; }
+    uint32_t GetPCODE()  override { return PCODE_MONITORRESULTX; }
     uint32_t GetLength() override;
     void Encode(FNET_DataBuffer *dst) override;
     bool Decode(FNET_DataBuffer *src, uint32_t len) override;
@@ -411,7 +370,6 @@ private:
     FS4Packet_QUERYRESULTX(const FS4Packet_QUERYRESULTX &);
     FS4Packet_QUERYRESULTX& operator=(const FS4Packet_QUERYRESULTX &);
 
-    uint32_t _pcode;
     uint32_t _distributionKey;
 
 public:
@@ -422,8 +380,6 @@ public:
     search::HitRank _maxRank;
     uint32_t *_sortIndex;    // if QRF_SORTDATA
     char     *_sortData;     // if QRF_SORTDATA
-    uint32_t _aggrDataLen;   // if QRF_AGGRDATA
-    char    *_aggrData;      // if QRF_AGGRDATA
     uint32_t _groupDataLen;  // if QRF_GROUPDATA
     char    *_groupData;     // if QRF_GROUPDATA
     uint64_t _coverageDocs;  // if QRF_COVERAGE
@@ -451,18 +407,13 @@ public:
     void AllocateSortIndex(uint32_t cnt);
     void AllocateSortData(uint32_t len);
     void SetSortDataRef(uint32_t cnt, uint32_t *sortIndex, const char *sortData);
-    void AllocateAggrData(uint32_t len);
-    void SetAggrDataRef(const char *aggrData, uint32_t len);
     void AllocateGroupData(uint32_t len);
     void SetGroupDataRef(const char *groupData, uint32_t len);
     void AllocateHits(uint32_t cnt);
 
-    FS4Packet_QUERYRESULTX(uint32_t pcode = PCODE_QUERYRESULTX);
+    FS4Packet_QUERYRESULTX();
     ~FS4Packet_QUERYRESULTX();
-    void UpdateCompatPCODE();
-    void UpdateCompatFeatures();
-    void SetRealPCODE() { _pcode = PCODE_QUERYRESULTX; }
-    uint32_t GetPCODE() override { return _pcode; }
+    uint32_t GetPCODE() override { return PCODE_QUERYRESULTX; }
     uint32_t GetLength() override;
     void Encode(FNET_DataBuffer *dst) override;
     bool Decode(FNET_DataBuffer *src, uint32_t len) override ;
@@ -479,7 +430,6 @@ private:
     FS4Packet_QUERYX(const FS4Packet_QUERYX &);
     FS4Packet_QUERYX& operator=(const FS4Packet_QUERYX &);
 
-    uint32_t  _pcode;
     uint32_t  _timeout;
 
 public:
@@ -490,7 +440,6 @@ public:
     string    _ranking;       // if QF_RANKP
     PropsVector _propsVector; // if QF_PROPERTIES
     string    _sortSpec;      // if QF_SORTSPEC
-    string    _aggrSpec;      // if QF_AGGRSPEC
     string    _groupSpec;     // if QF_GROUPSPEC
     string    _sessionId;     // if QF_SESSIONID
     string    _location;      // if QF_LOCATION
@@ -500,7 +449,6 @@ public:
 
     void setRanking(const vespalib::stringref &ranking) { _ranking = ranking; }
     void setSortSpec(const vespalib::stringref &spec) { _sortSpec = spec; }
-    void setAggrSpec(const vespalib::stringref &spec) { _aggrSpec = spec; }
     void setGroupSpec(const vespalib::stringref &spec) { _groupSpec = spec; }
     void setSessionId(const vespalib::stringref &sid) { _sessionId = sid; }
     void setLocation(const vespalib::stringref &loc) { _location = loc; }
@@ -508,12 +456,9 @@ public:
     void setTimeout(const fastos::TimeStamp & timeout);
     fastos::TimeStamp getTimeout() const;
 
-    explicit FS4Packet_QUERYX(uint32_t pcode = PCODE_QUERYX);
+    explicit FS4Packet_QUERYX();
     ~FS4Packet_QUERYX();
-    void UpdateCompatPCODE();
-    void UpdateCompatFeatures();
-    void SetRealPCODE() { _pcode = PCODE_QUERYX; }
-    uint32_t GetPCODE() override { return _pcode; }
+    uint32_t GetPCODE() override { return PCODE_QUERYX; }
     uint32_t GetLength() override;
     void Encode(FNET_DataBuffer *dst) override;
     bool Decode(FNET_DataBuffer *src, uint32_t len) override;
@@ -528,7 +473,6 @@ private:
     FS4Packet_GETDOCSUMSX(const FS4Packet_GETDOCSUMSX &);
     FS4Packet_GETDOCSUMSX& operator=(const FS4Packet_GETDOCSUMSX &);
 
-    uint32_t       _pcode;
     uint32_t       _timeout;
 public:
     uint32_t       _features;          // see getdocsums_features
@@ -545,9 +489,8 @@ public:
         FS4_docid() : _gid(), _partid(0) { }
         document::GlobalId _gid;
         uint32_t _partid;           // if GDF_MLD
-    } *_docid;
-
-    uint32_t       _docidCnt;
+    };
+    std::vector<FS4_docid> _docid;
 
     void AllocateDocIDs(uint32_t cnt);
 
@@ -558,12 +501,9 @@ public:
     void setTimeout(const fastos::TimeStamp & timeout);
     fastos::TimeStamp getTimeout() const;
 
-    FS4Packet_GETDOCSUMSX(uint32_t pcode = PCODE_GETDOCSUMSX);
+    FS4Packet_GETDOCSUMSX();
     ~FS4Packet_GETDOCSUMSX();
-    void UpdateCompatPCODE();
-    void UpdateCompatFeatures();
-    void SetRealPCODE() { _pcode = PCODE_GETDOCSUMSX; }
-    uint32_t GetPCODE() override { return _pcode; }
+    uint32_t GetPCODE() override { return PCODE_GETDOCSUMSX; }
     uint32_t GetLength() override;
     void Encode(FNET_DataBuffer *dst) override;
     bool Decode(FNET_DataBuffer *src, uint32_t len) override;
diff --git a/searchlib/src/vespa/searchlib/common/transport.h b/searchlib/src/vespa/searchlib/common/transport.h
index 9b4f2ecb5c2..dc99b66ec8a 100644
--- a/searchlib/src/vespa/searchlib/common/transport.h
+++ b/searchlib/src/vespa/searchlib/common/transport.h
@@ -8,21 +8,15 @@
 
 #include <vespa/fastos/fastos.h>
 
-namespace search
-{
+namespace search {
 
-namespace fs4transport
-{
+namespace fs4transport {
 
 /**
  * Instead of using a 32-bit number to send the 'usehardware' flag, we
  * now use this 32-bit number to send 32 flags. The currently defined flags
  * are as follows:
  * <ul>
- *  <li><b>QFLAG_ALLOW_ERRORPACKET</b>: Allow an error packet to be sent as
- *                                response to this query packet.</li>
- *  <li><b>QFLAG_REPORT_QUEUELEN</b>: Send an extra queue length packet before
- *                                query result packets.</li>
  *  <li><b>QFLAG_ESTIMATE</b>: Indicates that the  query is performed to get
  *                             an estimate of the total number of hits</li>
  *  <li><b>QFLAG_DUMP_FEATURES</b>: Dump detailed ranking information. Note that
@@ -35,18 +29,10 @@ namespace fs4transport
  * </ul>
  **/
 enum queryflags {
-    QFLAG_ALLOW_ERRORPACKET    = 0x00000004,
-    QFLAG_REPORT_QUEUELEN      = 0x00000008,
     QFLAG_ESTIMATE             = 0x00000080,
     QFLAG_DROP_SORTDATA        = 0x00004000,
-    QFLAG_REPORT_COVERAGE      = 0x00008000,
     QFLAG_NO_RESULTCACHE       = 0x00010000,
-    QFLAG_DUMP_FEATURES        = 0x00040000,
-
-    QFLAG_CACHE_MASK           = (// which flags affect the cache
-                                  QFLAG_ESTIMATE |
-                                  QFLAG_DROP_SORTDATA |
-                                  QFLAG_REPORT_COVERAGE)
+    QFLAG_DUMP_FEATURES        = 0x00040000
 };
 
 
@@ -55,11 +41,7 @@ enum queryflags {
  * 'featureflags'. Each bit in that field denotes a separate feature
  * that may be present in the query result packet or not. The comment
  * describing the packet format indicates what data fields depend on
- * what features. Note that after removing the query id and the
- * feature flags from a PCODE_QUERYRESULTX packet it is binary
- * compatible with the PCODE_QUERYRESULT, PCODE_MLD_QUERYRESULT and
- * PCODE_MLD_QUERYRESULT2 packets given the correct set of
- * features. The features present in the 'old' query result packets
+ * what features. The features present in the 'old' query result packets
  * are defined in this enum along with the Query Result Features
  * themselves. The value called QRF_SUPPORTED_MASK denotes which
  * features are supported by the current version. If a packet with
@@ -69,13 +51,9 @@ enum queryflags {
 enum queryresult_features {
     QRF_MLD                   = 0x00000001,
     QRF_SORTDATA              = 0x00000010,
-    QRF_AGGRDATA              = 0x00000020,
     QRF_COVERAGE              = 0x00000040,
     QRF_GROUPDATA             = 0x00000200,
-    QRF_PROPERTIES            = 0x00000400,
-
-    QRF_QUERYRESULT_MASK      = 0,
-    QRF_MLD_QUERYRESULT_MASK  = QRF_MLD
+    QRF_PROPERTIES            = 0x00000400
 };
 
 
@@ -84,10 +62,7 @@ enum queryresult_features {
  * 'featureflags'. Each bit in that field denotes a separate feature
  * that may be present in the query packet or not. The comment
  * describing the packet format indicates what data fields depend on
- * what features. Note that after removing the query id and the
- * feature flags from a PCODE_QUERYX packet it is binary compatible
- * with the PCODE_PARSEDQUERY2 packets
- * given the correct set of features. The features present in the
+ * what features. The features present in the
  * 'old' query packets are defined in this enum along with the Query
  * Features themselves. The values called
  * QF_SUPPORTED_[FSEARCH/FDISPATCH]_MASK denotes which features are
@@ -99,14 +74,10 @@ enum query_features {
     QF_PARSEDQUERY            = 0x00000002,
     QF_RANKP                  = 0x00000004,
     QF_SORTSPEC               = 0x00000080,
-    QF_AGGRSPEC               = 0x00000100,
     QF_LOCATION               = 0x00000800,
     QF_PROPERTIES             = 0x00100000,
-    QF_WARMUP		      = 0x00200000, // Deprecated, do not use!
     QF_GROUPSPEC              = 0x00400000,
-    QF_SESSIONID              = 0x00800000,
-
-    QF_PARSEDQUERY2_MASK      = (QF_PARSEDQUERY | QF_RANKP)
+    QF_SESSIONID              = 0x00800000
 };
 
 
@@ -115,11 +86,7 @@ enum query_features {
  * 'featureflags'. Each bit in that field denotes a separate feature
  * that may be present in the getdocsums packet or not. The comment
  * describing the packet format indicates what data fields depend on
- * what features. Note that after removing the query id and the
- * feature flags from a PCODE_GETDOCSUMSX packet it is binary
- * compatible with the PCODE_GETDOCSUMS, PCODE_MLD_GETDOCSUMS and
- * PCODE_MLD_GETDOCSUMS2 packets given the correct set of
- * features. The features present in the 'old' getdocsums packets are
+ * what features. The features present in the 'old' getdocsums packets are
  * defined in this enum along with the GetDocsums Features
  * themselves. The values called
  * GDF_SUPPORTED_[FSEARCH/FDISPATCH]_MASK denotes which features are
@@ -134,15 +101,11 @@ enum getdocsums_features {
     GDF_LOCATION              = 0x00000080,
     GDF_RESCLASSNAME          = 0x00000800,
     GDF_PROPERTIES            = 0x00001000,
-    GDF_FLAGS                 = 0x00002000,
-
-    GDF_GETDOCSUMS_MASK       = 0,
-    GDF_MLD_GETDOCSUMS_MASK   = (GDF_MLD)
+    GDF_FLAGS                 = 0x00002000
 };
 
 
-enum getdocsums_flags
-{
+enum getdocsums_flags {
     GDFLAG_IGNORE_ROW         = 0x00000001,
     GDFLAG_ALLOW_SLIME        = 0x00000002
 };
@@ -150,38 +113,20 @@ enum getdocsums_flags
 // docsum class for slime tunneling
 const uint32_t SLIME_MAGIC_ID = 0x55555555;
 
-enum monitorquery_features
-{
+enum monitorquery_features {
     MQF_QFLAGS		    = 0x00000002,			
-
-    MQF_MONITORQUERY_MASK   = 0
 };
 
-
-enum monitorquery_flags
-{
-    // NOT_USED MQFLAG_REPORT_SOFTOFFLINE = 0x00000010,
+enum monitorquery_flags {
     MQFLAG_REPORT_ACTIVEDOCS  = 0x00000020
 };
 
-
-enum monitorresult_features
-{
+enum monitorresult_features {
     MRF_MLD		    = 0x00000001,
     MRF_RFLAGS		    = 0x00000008,
     MRF_ACTIVEDOCS	    = 0x00000010,
-
-    MRF_MONITORRESULT_MASK  = 0,
-    MRF_MLD_MONITORRESULT_MASK = (MRF_MLD)
-};
-
-
-enum monitorresult_flags
-{
-    // NOT_USED MRFLAG_SOFTOFFLINE       = 0x00000001
 };
 
-
 /**
  * Codes for packets between dispatch nodes and search nodes.
  * general packet (i.e. message) format:
@@ -193,83 +138,30 @@ enum packetcode {
     PCODE_EOL = 200,	/* ..fdispatch <-> ..fsearch.	PacketData:
 			 *0	{uint32_t queryId,}	- only in new format!*/
     PCODE_QUERY_NOTUSED = 201,
-    PCODE_QUERYRESULT = 202,	/* ..fdispatch <-  ..fsearch.	PacketData:
-			 *0	{uint32_t queryId,}	- only in new format!
-			 *1	uint32_t offset,
-			 *2	uint32_t numDocs,
-			 *3	uint32_t totNumDocs,
-			 *4	search::HitRank maxRank,
-			 *5	time_t docstamp,	- sent as Uint32
-			 *6	struct FastS_connhitresult {
-			 *	    uint32_t docid;
-			 *	    search::HitRank metric
-			 *	}[] hits				     */
+    PCODE_QUERYRESULT_NOTUSED = 202,
     PCODE_ERROR = 203,          /* ..fdispatch <-  ..fsearch/..fdispatch
                            *	{uint32_t queryId,}	- only in new format!
                            *      uint32_t  error_code  [see common/errorcodes.h]
                            *      uint32_t  message_len
                            *      char[]    message     (UTF-8)   */
-    PCODE_GETDOCSUMS = 204,	/* ..fdispatch  -> ..fsearch.	PacketData:
-			 *0	{uint32_t queryId,}	- only in new format!
-			 *	time_t docstamp		- header
-			 * 	uint32_t[] docid	- body	  	   */
+    PCODE_GETDOCSUMS_NOTUSED = 204,
     PCODE_DOCSUM = 205,		/* ..fdispatch <-  ..fsearch.
                                  *0	{uint32_t queryId,}	- only in new format!
                                  *1	uint32_t location
                                  *2	char[] <title, incipit, URL, ...>
                                  */
-    PCODE_MONITORQUERY = 206,	/* ..fdispatch  -> ..fsearch.	No packet data.
-			 */
-    PCODE_MONITORRESULT = 207,	/* ..fdispatch <-  ..fsearch.	PacketData:
-                                 *	int partitionId,
-                                 *	time_t timeStamp			     */
-    PCODE_MLD_QUERYRESULT = 208,/* ..fdispatch <-  ..fdispatch.
-                           * header: {queryId,} offset, numdocs, tnumdocs,
-                           *	maxRank, docstamp
-                           * body: (docid, metric, partition, docstamp)*
-                           */
-    PCODE_MLD_GETDOCSUMS = 209,	/* ..fdispatch  -> ..fdispatch.
-                                 * header: {queryId,} docstamp
-                                 * body: (docid, partition, docstamp)*
-                                 */
-    PCODE_MLD_MONITORRESULT = 210 ,/* ..fdispatch <- ..fdispatch	NB: no queryId!
-                             *	lowest partition id,
-                             *	timestamp,
-                             *	total number of nodes,
-                             *	active nodes,
-                             *	total number of partitions,
-                             *	active partitions
-                             */
-    PCODE_CLEARCACHES = 211,	/* ..fdispatch -> ..fdispatch.  No packet data/ NotUsed
-			 */
+    PCODE_MONITORQUERY_NOTUSED = 206,
+    PCODE_MONITORRESULT_NOTUSED = 207,
+    PCODE_MLD_QUERYRESULT_NOTUSED = 208,
+    PCODE_MLD_GETDOCSUMS_NOTUSED = 209,
+    PCODE_MLD_MONITORRESULT_NOTUSED = 210,
+    PCODE_CLEARCACHES_NOTUSED = 211,
     PCODE_QUERY2_NOTUSED = 212,
-    PCODE_PARSEDQUERY2 = 213,	/* ..fdispatch  -> ..fsearch.	PacketData:
-			 *0	{uint32_t queryId,}	- only in new format!
-			 *1	..query::querytypes searchType,	- all/any/exact
-			 *2	uint32_t offset,
-			 *3	uint32_t maxhits,
-			 *4	uint32_t qflags,	(including usehardware)
-			 *5     uint32_t rankprofile,   - enum
-			 *6     uint32_t numStackItems,
-			 *7	multiple encoded stackitems:
-                         - uint32_t OR|AND|NOT|RANK
-                         uint32_t arity
-                         - uint32_t PHRASE
-                         uint32_t arity
-                         uint32_t indexNameLen
-                         char[]   indexName
-                         - uint32_t TERM
-                         uint32_t indexNameLen
-                         char[]   indexName
-                         uint32_t termLen
-                         char[]   term
-                        */
+    PCODE_PARSEDQUERY2_NOTUSED = 213,
     PCODE_MLD_QUERYRESULT2_NOTUSED = 214,
     PCODE_MLD_GETDOCSUMS2_NOTUSED = 215,
+    PCODE_QUEUELEN_NOTUSED = 216,
 
-    PCODE_QUEUELEN = 216,	/* fdispatch <- fsearch.
-			 * header: queueLen, dispatchers
-			 */
     PCODE_QUERYRESULTX = 217,	/*
 			 *      {uint32_t queryId,}    - only if persistent
                          *      uint32_t featureflags, - see 'queryresult_features'
@@ -280,8 +172,6 @@ enum packetcode {
 			 *      uint32_t docstamp,
                          *      uint32_t[numDocs] sortIndex   - if QRF_SORTDATA
                          *      char[sidx[n - 1]] sortData    - if QRF_SORTDATA
-                         *      uint32_t          aggrDataLen - if QRF_AGGRDATA
-                         *      char[aggrDataLen] aggrData    - if QRF_AGGRDATA
                          *      uint32_t           groupDataLen - if QRF_GROUPDATA
                          *      char[groupDataLen] groupData    - if QRF_GROUPDATA
                          *      uint64_t coverageDocs  - if QRF_COVERAGE
@@ -315,8 +205,6 @@ enum packetcode {
                                  *      }
                                  *      uint32_t sortSpecLen         - if QF_SORTSPEC
                                  *      char[sortSpecLen] sortSpec   - if QF_SORTSPEC
-                                 *      uint32_t aggrSpecLen         - if QF_AGGRSPEC
-                                 *      char[aggrSpecLen] aggrSpec   - if QF_AGGRSPEC
                                  *      uint32_t groupSpecLen         - if QF_GROUPSPEC
                                  *      char[groupSpecLen] groupSpec  - if QF_GROUPSPEC
                                  *      uint32_t locationLen         - if QF_LOCATION
diff --git a/searchlib/src/vespa/searchlib/engine/packetconverter.cpp b/searchlib/src/vespa/searchlib/engine/packetconverter.cpp
index 9282c7cc820..8405f87a9c2 100644
--- a/searchlib/src/vespa/searchlib/engine/packetconverter.cpp
+++ b/searchlib/src/vespa/searchlib/engine/packetconverter.cpp
@@ -119,11 +119,9 @@ PacketConverter::fromSearchReply(const SearchReply &reply, QUERYRESULTX &packet)
         packet.AllocateGroupData(reply.groupResult.size());
         memcpy(packet._groupData, &(reply.groupResult[0]), reply.groupResult.size());
     }
-    if (reply.useCoverage) {
-        packet._features |= QRF_COVERAGE;
-        packet._coverageDocs = reply.coverage.getCovered();
-        packet._activeDocs = reply.coverage.getActive();
-    }
+    packet._features |= QRF_COVERAGE;
+    packet._coverageDocs = reply.coverage.getCovered();
+    packet._activeDocs = reply.coverage.getActive();
     if (reply.useWideHits) {
         packet._features |= QRF_MLD;
     }
@@ -161,7 +159,7 @@ PacketConverter::toDocsumRequest(const GETDOCSUMSX &packet, DocsumRequest &reque
     request.location = packet._location;
     request._flags = packet._flags;
     request.useWideHits = checkFeature(packet._features, GDF_MLD);
-    uint32_t hitCnt = packet._docidCnt;
+    uint32_t hitCnt = packet._docid.size();
     request.hits.resize(hitCnt);
     for (uint32_t i = 0; i < hitCnt; ++i) {
         request.hits[i].gid      = packet._docid[i]._gid;
diff --git a/searchlib/src/vespa/searchlib/engine/packetconverter.h b/searchlib/src/vespa/searchlib/engine/packetconverter.h
index f58bf6a9642..aea75186cde 100644
--- a/searchlib/src/vespa/searchlib/engine/packetconverter.h
+++ b/searchlib/src/vespa/searchlib/engine/packetconverter.h
@@ -35,7 +35,6 @@ private:
 public:
     typedef search::fs4transport::FS4Packet_QUERYX         QUERYX;
     typedef search::fs4transport::FS4Packet_QUERYRESULTX   QUERYRESULTX;
-    typedef search::fs4transport::FS4Packet_QUEUELEN       QUEUELEN;
     typedef search::fs4transport::FS4Packet_ERROR          ERROR;
     typedef search::fs4transport::FS4Packet_GETDOCSUMSX    GETDOCSUMSX;
     typedef search::fs4transport::FS4Packet_DOCSUM         DOCSUM;
diff --git a/searchlib/src/vespa/searchlib/engine/searchreply.cpp b/searchlib/src/vespa/searchlib/engine/searchreply.cpp
index 529be053e42..52a4431a239 100644
--- a/searchlib/src/vespa/searchlib/engine/searchreply.cpp
+++ b/searchlib/src/vespa/searchlib/engine/searchreply.cpp
@@ -18,14 +18,11 @@ SearchReply::SearchReply()
       sortIndex(),
       sortData(),
       groupResult(),
-      useCoverage(false),
       coverage(),
       useWideHits(false),
       hits(),
       errorCode(0),
       errorMessage(),
-      useQueueLen(false),
-      queueLen(0),
       request()
 {
 }
@@ -40,14 +37,11 @@ SearchReply::SearchReply(const SearchReply &rhs)
     sortIndex    (rhs.sortIndex),
     sortData     (rhs.sortData),
     groupResult  (rhs.groupResult),
-    useCoverage  (rhs.useCoverage),
     coverage     (rhs.coverage),
     useWideHits  (rhs.useWideHits),
     hits         (rhs.hits),
     errorCode    (rhs.errorCode),
     errorMessage (rhs.errorMessage),
-    useQueueLen  (rhs.useQueueLen),
-    queueLen     (rhs.queueLen),
     request() // NB not copied
 {
 }
diff --git a/searchlib/src/vespa/searchlib/engine/searchreply.h b/searchlib/src/vespa/searchlib/engine/searchreply.h
index 0e7ab43e66d..8a5fc7e2a2b 100644
--- a/searchlib/src/vespa/searchlib/engine/searchreply.h
+++ b/searchlib/src/vespa/searchlib/engine/searchreply.h
@@ -57,7 +57,6 @@ public:
     std::vector<uint32_t> sortIndex;
     std::vector<char>     sortData;
     vespalib::Array<char> groupResult;
-    bool                  useCoverage;
     Coverage              coverage;
     bool                  useWideHits;
     std::vector<Hit>      hits;
@@ -67,9 +66,6 @@ public:
     uint32_t              errorCode;
     vespalib::string      errorMessage;
 
-    // piggyback monitoring
-    bool                  useQueueLen;
-    uint32_t              queueLen;
     SearchRequest::UP     request;
 
     SearchReply();
diff --git a/searchlib/src/vespa/searchlib/engine/transportserver.cpp b/searchlib/src/vespa/searchlib/engine/transportserver.cpp
index cdde798b579..73594a950d1 100644
--- a/searchlib/src/vespa/searchlib/engine/transportserver.cpp
+++ b/searchlib/src/vespa/searchlib/engine/transportserver.cpp
@@ -32,19 +32,9 @@ TransportServer::SearchHandler::searchDone(SearchReply::UP reply)
     if (reply.get() != 0) {
         const SearchReply &r = *reply;
         if (r.valid) {
-            if (r.useQueueLen) {
-                PacketConverter::QUEUELEN *p = new PacketConverter::QUEUELEN();
-                p->_queueLen = r.queueLen;
-                p->_dispatchers = clientCnt;
-                if (shouldLog(DEBUG_SEARCH)) {
-                    logPacket("outgoing packet", p, 0, channel->GetConnection());
-                }
-                channel->GetConnection()->PostPacket(p, FNET_NOID);
-            }
             if (r.errorCode == 0) {
                 PacketConverter::QUERYRESULTX *p = new PacketConverter::QUERYRESULTX();
                 PacketConverter::fromSearchReply(r, *p);
-                p->UpdateCompatPCODE();
                 if (shouldLog(DEBUG_SEARCH)) {
                     logPacket("outgoing packet", p, channel, 0);
                 }
@@ -141,7 +131,6 @@ TransportServer::MonitorHandler::pingDone(MonitorReply::UP reply)
         const MonitorReply &r = *reply;
         PacketConverter::MONITORRESULTX *p = new PacketConverter::MONITORRESULTX();
         PacketConverter::fromMonitorReply(r, *p);
-        p->UpdateCompatPCODE();
         if (shouldLog(DEBUG_MONITOR)) {
             logPacket("outgoing packet", p, 0, connection);
         }