Move code to .cpp file and include what you need.

10 files changed, 380 insertions, 363 deletions

diff --git a/fnet/src/vespa/fnet/databuffer.h b/fnet/src/vespa/fnet/databuffer.h
index 8e4127d3b72..316755b883f 100644
--- a/fnet/src/vespa/fnet/databuffer.h
+++ b/fnet/src/vespa/fnet/databuffer.h
@@ -4,6 +4,7 @@
 
 #include <vespa/vespalib/util/compress.h>
 #include <vespa/vespalib/util/alloc.h>
+#include <cassert>
 
 /**
  * This is a buffer that may hold the stream representation of
diff --git a/fnet/src/vespa/fnet/fnet.h b/fnet/src/vespa/fnet/fnet.h
index 62c26ebc779..7e859ea5e75 100644
--- a/fnet/src/vespa/fnet/fnet.h
+++ b/fnet/src/vespa/fnet/fnet.h
@@ -12,45 +12,11 @@
 
 // DEFINES
 
-// THREAD/MUTEX STUFF
-
-#ifdef FASTOS_NO_THREADS
-
-#define FNET_HAS_THREADS false
-
-class FNET_Mutex
-{
-public:
-    FNET_Mutex(const char *, bool) {}
-    void Lock() {}
-    void Unlock() {}
-};
-
-class FNET_Cond : public FNET_Mutex
-{
-    bool Illegal(const char *name) {
-        fprintf(stderr, "FNET_Cond::%s called (FASTOS_NO_THREADS)\n", name);
-        abort();
-        return false;
-    }
-public:
-    FNET_Cond(const char *name, bool leaf)
-        : FNET_Mutex(name, leaf) {}
-    bool TimedWait(int) { return Illegal("TimedWait"); }
-    void Wait() { Illegal("Wait"); }
-    void Signal() { Illegal("Signal"); }
-    void Broadcast() { Illegal("Broadcast"); }
-};
-
-#else // FASTOS_NO_THREADS
-
 #define FNET_HAS_THREADS true
 
 typedef FastOS_Mutex FNET_Mutex;
 typedef FastOS_Cond  FNET_Cond;
 
-#endif
-
 // DEPRECATED
 
 #define DEPRECATED __attribute__((deprecated))
diff --git a/fnet/src/vespa/fnet/frt/memorytub.h b/fnet/src/vespa/fnet/frt/memorytub.h
index 3ac27a5079a..abed57c75a6 100644
--- a/fnet/src/vespa/fnet/frt/memorytub.h
+++ b/fnet/src/vespa/fnet/frt/memorytub.h
@@ -2,7 +2,9 @@
 
 #pragma once
 
-#include <new>
+#include <vespa/vespalib/util/alloc.h>
+#include <cstring>
+
 
 class FRT_MemoryTub
 {
diff --git a/fnet/src/vespa/fnet/frt/packets.h b/fnet/src/vespa/fnet/frt/packets.h
index e52baaa3871..424a3d12190 100644
--- a/fnet/src/vespa/fnet/frt/packets.h
+++ b/fnet/src/vespa/fnet/frt/packets.h
@@ -2,6 +2,8 @@
 
 #pragma once
 
+#include <vespa/fnet/packet.h>
+#include <vespa/fnet/ipacketfactory.h>
 
 enum {
     PCODE_FRT_RPC_FIRST          = 100,
@@ -30,9 +32,7 @@ protected:
     FRT_RPCPacket &operator=(const FRT_RPCPacket &);
 
 public:
-    FRT_RPCPacket(FRT_RPCRequest *req,
-                  uint32_t flags,
-                  bool ownsRef)
+    FRT_RPCPacket(FRT_RPCRequest *req, uint32_t flags, bool ownsRef)
         : _req(req),
           _flags(flags),
           _ownsRef(ownsRef)
diff --git a/fnet/src/vespa/fnet/frt/rpcrequest.cpp b/fnet/src/vespa/fnet/frt/rpcrequest.cpp
index 78789ccd4e9..390cd6fed9c 100644
--- a/fnet/src/vespa/fnet/frt/rpcrequest.cpp
+++ b/fnet/src/vespa/fnet/frt/rpcrequest.cpp
@@ -1,7 +1,9 @@
 // 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 <vespa/fnet/frt/frt.h>
+#include "rpcrequest.h"
+#include "packets.h"
+#include <vespa/fnet/info.h>
+#include <cassert>
 
 FRT_RPCRequest::FRT_RPCRequest()
     : _tub(),
@@ -28,6 +30,24 @@ FRT_RPCRequest::~FRT_RPCRequest()
     assert(_refcnt == 0);
 }
 
+void
+FRT_RPCRequest::SetError(uint32_t errorCode, const char *errorMessage, uint32_t errorMessageLen)
+{
+    _errorCode = errorCode;
+    _errorMessageLen = errorMessageLen;
+    _errorMessage = _tub.CopyString(errorMessage,
+                                    errorMessageLen);
+}
+void
+FRT_RPCRequest::SetError(uint32_t errorCode, const char *errorMessage) {
+    SetError(errorCode, errorMessage, strlen(errorMessage));
+}
+
+void
+FRT_RPCRequest::SetError(uint32_t errorCode)
+{
+    SetError(errorCode, FRT_GetDefaultErrorMessage(errorCode));
+}
 
 void
 FRT_RPCRequest::Reset()
diff --git a/fnet/src/vespa/fnet/frt/rpcrequest.h b/fnet/src/vespa/fnet/frt/rpcrequest.h
index ec0018fa451..2d7ee0d8c7b 100644
--- a/fnet/src/vespa/fnet/frt/rpcrequest.h
+++ b/fnet/src/vespa/fnet/frt/rpcrequest.h
@@ -2,8 +2,14 @@
 
 #pragma once
 
+#include "values.h"
+#include "error.h"
+#include <vespa/fnet/context.h>
+
 #include <vespa/vespalib/util/atomic.h>
 
+class FNETConnection;
+class FNET_Packet;
 
 class FRT_IAbortHandler
 {
@@ -106,18 +112,9 @@ public:
 
     bool GetCompletionToken() { return (vespalib::Atomic::postInc(&_completed) == 0); }
 
-    void SetError(uint32_t errorCode, const char *errorMessage,
-                  uint32_t errorMessageLen)
-    {
-        _errorCode = errorCode;
-        _errorMessageLen = errorMessageLen;
-        _errorMessage = _tub.CopyString(errorMessage,
-                                        errorMessageLen);
-    }
-    void SetError(uint32_t errorCode, const char *errorMessage)
-    { SetError(errorCode, errorMessage, strlen(errorMessage)); }
-    void SetError(uint32_t errorCode)
-    { SetError(errorCode, FRT_GetDefaultErrorMessage(errorCode)); }
+    void SetError(uint32_t errorCode, const char *errorMessage, uint32_t errorMessageLen);
+    void SetError(uint32_t errorCode, const char *errorMessage);
+    void SetError(uint32_t errorCode);
 
     bool IsError() { return (_errorCode != FRTE_NO_ERROR); }
     uint32_t GetErrorCode() { return _errorCode; }
@@ -152,7 +149,7 @@ public:
     FNET_Packet *CreateReplyPacket();
 
     void SetDetachedPT(bool *detachedPT) { _detachedPT = detachedPT; }
-    void Detach() { assert(_detachedPT != NULL); *_detachedPT = true; }
+    void Detach() { *_detachedPT = true; }
 
     void SetAbortHandler(FRT_IAbortHandler *handler)
     { _abortHandler = handler; }
@@ -169,9 +166,7 @@ public:
         return _abortHandler->HandleAbort();
     }
 
-    void Return()
-    {
-        assert(_returnHandler != NULL);
+    void Return() {
         _returnHandler->HandleReturn();
     }
 
diff --git a/fnet/src/vespa/fnet/frt/values.cpp b/fnet/src/vespa/fnet/frt/values.cpp
index 007b3c848e6..d97dfd17dac 100644
--- a/fnet/src/vespa/fnet/frt/values.cpp
+++ b/fnet/src/vespa/fnet/frt/values.cpp
@@ -1,7 +1,293 @@
 // 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 <vespa/fnet/frt/frt.h>
+#include "values.h"
+#include <vespa/fnet/databuffer.h>
+#include <vespa/vespalib/util/stringfmt.h>
+#include <cassert>
+
+static_assert(sizeof(uint8_t) == 1, "uint8_t must be 1 byte.");
+static_assert(sizeof(float)   == sizeof(uint32_t), "float must be same size as uint32_t");
+static_assert(sizeof(double)  == sizeof(uint64_t), "double must be same size as uint64_t");
+
+FRT_Values::FRT_Values(FRT_MemoryTub *tub)
+    : _maxValues(0),
+      _numValues(0),
+      _typeString(NULL),
+      _values(NULL),
+      _blobs(NULL),
+      _tub(tub)
+{ }
+
+FRT_Values::~FRT_Values() { }
+
+void
+FRT_Values::DiscardBlobs()
+{
+    while (_blobs != NULL) {
+        BlobRef *ref = _blobs;
+        _blobs = ref->_next;
+        FRT_ISharedBlob *blob = ref->_blob;
+        FRT_DataValue *value = ref->_value;
+        if (value == NULL) {
+            uint32_t idx = ref->_idx;
+            assert(_numValues > idx);
+            assert(_typeString[idx] == 'x');
+            value = &_values[idx]._data;
+        }
+        if ((value->_buf == blob->getData()) && (value->_len == blob->getLen())) {
+            value->_buf = NULL;
+            value->_len = 0;
+        }
+        ref->~BlobRef();
+    }
+}
+
+void
+FRT_Values::EnsureFree(uint32_t need)
+{
+    if (_numValues + need <= _maxValues)
+        return;
+
+    uint32_t cnt = _maxValues * 2;
+    if (cnt < _numValues + need)
+        cnt = _numValues + need;
+    if (cnt < 16)
+        cnt = 16;
+
+    char *types = (char *) _tub->Alloc(cnt + 1);
+    memcpy(types, _typeString, _numValues);
+    memset(types + _numValues, FRT_VALUE_NONE, cnt + 1 - _numValues);
+    FRT_Value *values = (FRT_Value *) _tub->Alloc(cnt * sizeof(FRT_Value));
+    memcpy(values, _values, _numValues * sizeof(FRT_Value));
+    _maxValues  = cnt;
+    _typeString = types;
+    _values     = values;
+}
+
+uint8_t *
+FRT_Values::AddInt8Array(uint32_t len) {
+    EnsureFree();
+    uint8_t *ret = (uint8_t *) _tub->Alloc(len * sizeof(uint8_t));
+    _values[_numValues]._int8_array._pt = ret;
+    _values[_numValues]._int8_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_INT8_ARRAY;
+    return ret;
+}
+
+void
+FRT_Values::AddInt8Array(const uint8_t *array, uint32_t len) {
+    EnsureFree();
+    uint8_t *pt = (uint8_t *) _tub->Alloc(len * sizeof(uint8_t));
+    _values[_numValues]._int8_array._pt = pt;
+    _values[_numValues]._int8_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_INT8_ARRAY;
+    memcpy(pt, array, len * sizeof(uint8_t));
+}
+
+uint16_t *
+FRT_Values::AddInt16Array(uint32_t len) {
+    EnsureFree();
+    uint16_t *ret = (uint16_t *) _tub->Alloc(len * sizeof(uint16_t));
+    _values[_numValues]._int16_array._pt = ret;
+    _values[_numValues]._int16_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_INT16_ARRAY;
+    return ret;
+}
+
+void
+FRT_Values::AddInt16Array(const uint16_t *array, uint32_t len) {
+    EnsureFree();
+    uint16_t *pt = (uint16_t *) _tub->Alloc(len * sizeof(uint16_t));
+    _values[_numValues]._int16_array._pt = pt;
+    _values[_numValues]._int16_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_INT16_ARRAY;
+    memcpy(pt, array, len * sizeof(uint16_t));
+}
+
+uint32_t *
+FRT_Values::AddInt32Array(uint32_t len) {
+    EnsureFree();
+    uint32_t *ret = (uint32_t *) _tub->Alloc(len * sizeof(uint32_t));
+    _values[_numValues]._int32_array._pt = ret;
+    _values[_numValues]._int32_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_INT32_ARRAY;
+    return ret;
+}
+
+void
+FRT_Values::AddInt32Array(const uint32_t *array, uint32_t len) {
+    EnsureFree();
+    uint32_t *pt = (uint32_t *) _tub->Alloc(len * sizeof(uint32_t));
+    _values[_numValues]._int32_array._pt = pt;
+    _values[_numValues]._int32_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_INT32_ARRAY;
+    memcpy(pt, array, len * sizeof(uint32_t));
+}
+
+uint64_t *
+FRT_Values::AddInt64Array(uint32_t len) {
+    EnsureFree();
+    uint64_t *ret = (uint64_t *) _tub->Alloc(len * sizeof(uint64_t));
+    _values[_numValues]._int64_array._pt = ret;
+    _values[_numValues]._int64_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_INT64_ARRAY;
+    return ret;
+}
+
+void
+FRT_Values::AddInt64Array(const uint64_t *array, uint32_t len) {
+    EnsureFree();
+    uint64_t *pt = (uint64_t *) _tub->Alloc(len * sizeof(uint64_t));
+    _values[_numValues]._int64_array._pt = pt;
+    _values[_numValues]._int64_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_INT64_ARRAY;
+    memcpy(pt, array, len * sizeof(uint64_t));
+}
+
+float *
+FRT_Values::AddFloatArray(uint32_t len) {
+    EnsureFree();
+    float *ret = (float *) _tub->Alloc(len * sizeof(float));
+    _values[_numValues]._float_array._pt = ret;
+    _values[_numValues]._float_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_FLOAT_ARRAY;
+    return ret;
+}
+
+void
+FRT_Values::AddFloatArray(const float *array, uint32_t len) {
+    EnsureFree();
+    float *pt = (float *) _tub->Alloc(len * sizeof(float));
+    _values[_numValues]._float_array._pt = pt;
+    _values[_numValues]._float_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_FLOAT_ARRAY;
+    memcpy(pt, array, len * sizeof(float));
+}
+
+double *
+FRT_Values::AddDoubleArray(uint32_t len) {
+    EnsureFree();
+    double *ret = (double *) _tub->Alloc(len * sizeof(double));
+    _values[_numValues]._double_array._pt = ret;
+    _values[_numValues]._double_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_DOUBLE_ARRAY;
+    return ret;
+}
+
+void
+FRT_Values::AddDoubleArray(const double *array, uint32_t len) {
+    EnsureFree();
+    double *pt = (double *) _tub->Alloc(len * sizeof(double));
+    _values[_numValues]._double_array._pt = pt;
+    _values[_numValues]._double_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_DOUBLE_ARRAY;
+    memcpy(pt, array, len * sizeof(double));
+}
+
+void
+FRT_Values::AddString(const char *str, uint32_t len) {
+    EnsureFree();
+    _values[_numValues]._string._str = _tub->CopyString(str, len);
+    _values[_numValues]._string._len = len;
+    _typeString[_numValues++] = FRT_VALUE_STRING;
+}
+
+char *
+FRT_Values::AddString(uint32_t len) {
+    EnsureFree();
+    char *ret = (char *) _tub->Alloc(len + 1);
+    _values[_numValues]._string._str = ret;
+    _values[_numValues]._string._len = len;
+    _typeString[_numValues++] = FRT_VALUE_STRING;
+    return ret;
+}
+
+FRT_StringValue *
+FRT_Values::AddStringArray(uint32_t len) {
+    EnsureFree();
+    FRT_StringValue *ret = (FRT_StringValue *) _tub->Alloc(len * sizeof(FRT_StringValue));
+    _values[_numValues]._string_array._pt = ret;
+    _values[_numValues]._string_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_STRING_ARRAY;
+    return ret;
+}
+
+void
+FRT_Values::AddSharedData(FRT_ISharedBlob *blob) {
+    EnsureFree();
+    _blobs = new (_tub) BlobRef(NULL, _numValues, blob, _blobs);
+    _values[_numValues]._data._buf = const_cast<char *>(blob->getData());
+    _values[_numValues]._data._len = blob->getLen();
+    _typeString[_numValues++] = FRT_VALUE_DATA;
+}
+
+void
+FRT_Values::AddData(vespalib::alloc::Alloc buf, uint32_t len) {
+    AddSharedData(new (_tub) LocalBlob(std::move(buf), len));
+}
+
+void
+FRT_Values::AddData(const char *buf, uint32_t len) {
+    if (len > FRT_MemoryTub::ALLOC_LIMIT) {
+        return AddSharedData(new (_tub) LocalBlob(buf, len));
+    }
+    EnsureFree();
+    _values[_numValues]._data._buf = _tub->CopyData(buf, len);
+    _values[_numValues]._data._len = len;
+    _typeString[_numValues++] = FRT_VALUE_DATA;
+}
+
+char *
+FRT_Values::AddData(uint32_t len) {
+    if (len > FRT_MemoryTub::ALLOC_LIMIT) {
+        LocalBlob *blob = new (_tub) LocalBlob(NULL, len);
+        AddSharedData(blob);
+        return blob->getInternalData();
+    }
+    EnsureFree();
+    char *ret = (char *) _tub->Alloc(len);
+    _values[_numValues]._data._buf = ret;
+    _values[_numValues]._data._len = len;
+    _typeString[_numValues++] = FRT_VALUE_DATA;
+    return ret;
+}
+
+FRT_DataValue *
+FRT_Values::AddDataArray(uint32_t len) {
+    EnsureFree();
+    FRT_DataValue *ret = (FRT_DataValue *) _tub->Alloc(len * sizeof(FRT_DataValue));
+    _values[_numValues]._data_array._pt = ret;
+    _values[_numValues]._data_array._len = len;
+    _typeString[_numValues++] = FRT_VALUE_DATA_ARRAY;
+    return ret;
+}
+
+void
+FRT_Values::SetString(FRT_StringValue *value, const char *str, uint32_t len) {
+    value->_str = _tub->CopyString(str, len);
+    value->_len = len;
+}
+
+void
+FRT_Values::SetString(FRT_StringValue *value, const char *str) {
+    uint32_t len = strlen(str);
+    value->_str = _tub->CopyString(str, len);
+    value->_len = len;
+}
+
+void
+FRT_Values::SetData(FRT_DataValue *value, const char *buf, uint32_t len) {
+    char *mybuf = NULL;
+    if (len > FRT_MemoryTub::ALLOC_LIMIT) {
+        LocalBlob *blob = new (_tub) LocalBlob(buf, len);
+        _blobs = new (_tub) BlobRef(value, 0, blob, _blobs);
+        mybuf = blob->getInternalData();
+    } else {
+        mybuf = _tub->CopyData(buf, len);
+    }
+    value->_buf = mybuf;
+    value->_len = len;
+}
 
 
 void
diff --git a/fnet/src/vespa/fnet/frt/values.h b/fnet/src/vespa/fnet/frt/values.h
index 7e889466941..cc3f2d3f4c8 100644
--- a/fnet/src/vespa/fnet/frt/values.h
+++ b/fnet/src/vespa/fnet/frt/values.h
@@ -2,6 +2,11 @@
 
 #pragma once
 
+#include "memorytub.h"
+#include "isharedblob.h"
+
+class FNET_DataBuffer;
+
 template <typename T>
 struct FRT_Array {
     uint32_t _len;
@@ -121,45 +126,15 @@ private:
     BlobRef       *_blobs;
     FRT_MemoryTub *_tub;
 
-    FRT_Values(const FRT_Values &);
-    FRT_Values &operator=(const FRT_Values &);
-
 public:
-    FRT_Values(FRT_MemoryTub *tub)
-        : _maxValues(0),
-          _numValues(0),
-          _typeString(NULL),
-          _values(NULL),
-          _blobs(NULL),
-          _tub(tub)
-    {
-        assert(sizeof(uint8_t) == 1);
-        assert(sizeof(float)   == sizeof(uint32_t));
-        assert(sizeof(double)  == sizeof(uint64_t));
-    }
+    FRT_Values(const FRT_Values &) = delete;
+    FRT_Values &operator=(const FRT_Values &) = delete;
+    FRT_Values(FRT_MemoryTub *tub);
+    ~FRT_Values();
 
-    void DiscardBlobs() {
-        while (_blobs != NULL) {
-            BlobRef *ref = _blobs;
-            _blobs = ref->_next;
-            FRT_ISharedBlob *blob = ref->_blob;
-            FRT_DataValue *value = ref->_value;
-            if (value == NULL) {
-                uint32_t idx = ref->_idx;
-                assert(_numValues > idx);
-                assert(_typeString[idx] == 'x');
-                value = &_values[idx]._data;
-            }
-            if ((value->_buf == blob->getData()) && (value->_len == blob->getLen())) {
-                value->_buf = NULL;
-                value->_len = 0;
-            }
-            ref->~BlobRef();
-        }
-    }
+    void DiscardBlobs();
 
-    void Reset()
-    {
+    void Reset() {
         DiscardBlobs();
         _maxValues  = 0;
         _numValues  = 0;
@@ -167,349 +142,123 @@ public:
         _values     = NULL;
     }
 
-    void EnsureFree(uint32_t need = 1)
-    {
-        if (_numValues + need <= _maxValues)
-            return;
-
-        uint32_t cnt = _maxValues * 2;
-        if (cnt < _numValues + need)
-            cnt = _numValues + need;
-        if (cnt < 16)
-            cnt = 16;
-
-        char *types = (char *) _tub->Alloc(cnt + 1);
-        memcpy(types, _typeString, _numValues);
-        memset(types + _numValues, FRT_VALUE_NONE, cnt + 1 - _numValues);
-        FRT_Value *values = (FRT_Value *) _tub->Alloc(cnt * sizeof(FRT_Value));
-        memcpy(values, _values, _numValues * sizeof(FRT_Value));
-        _maxValues  = cnt;
-        _typeString = types;
-        _values     = values;
-    }
+    void EnsureFree(uint32_t need = 1);
 
-    void AddInt8(uint8_t value)
-    {
+    void AddInt8(uint8_t value) {
         EnsureFree();
         _values[_numValues]._intval8 = value;
         _typeString[_numValues++] = FRT_VALUE_INT8;
     }
 
-    uint8_t *AddInt8Array(uint32_t len)
-    {
-        EnsureFree();
-        uint8_t *ret = (uint8_t *) _tub->Alloc(len * sizeof(uint8_t));
-        _values[_numValues]._int8_array._pt = ret;
-        _values[_numValues]._int8_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_INT8_ARRAY;
-        return ret;
-    }
+    uint8_t *AddInt8Array(uint32_t len);
 
-    void AddInt8Array(const uint8_t *array, uint32_t len)
-    {
-        EnsureFree();
-        uint8_t *pt = (uint8_t *) _tub->Alloc(len * sizeof(uint8_t));
-        _values[_numValues]._int8_array._pt = pt;
-        _values[_numValues]._int8_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_INT8_ARRAY;
-        memcpy(pt, array, len * sizeof(uint8_t));
-    }
+    void AddInt8Array(const uint8_t *array, uint32_t len);
 
-    void AddInt8ArrayRef(uint8_t *array, uint32_t len)
-    {
+    void AddInt8ArrayRef(uint8_t *array, uint32_t len) {
         EnsureFree();
         _values[_numValues]._int8_array._pt = array;
         _values[_numValues]._int8_array._len = len;
         _typeString[_numValues++] = FRT_VALUE_INT8_ARRAY;
     }
 
-    void AddInt16(uint16_t value)
-    {
+    void AddInt16(uint16_t value) {
         EnsureFree();
         _values[_numValues]._intval16 = value;
         _typeString[_numValues++] = FRT_VALUE_INT16;
     }
 
-    uint16_t *AddInt16Array(uint32_t len)
-    {
-        EnsureFree();
-        uint16_t *ret = (uint16_t *) _tub->Alloc(len * sizeof(uint16_t));
-        _values[_numValues]._int16_array._pt = ret;
-        _values[_numValues]._int16_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_INT16_ARRAY;
-        return ret;
-    }
+    uint16_t *AddInt16Array(uint32_t len);
+    void AddInt16Array(const uint16_t *array, uint32_t len);
 
-    void AddInt16Array(const uint16_t *array, uint32_t len)
-    {
-        EnsureFree();
-        uint16_t *pt = (uint16_t *) _tub->Alloc(len * sizeof(uint16_t));
-        _values[_numValues]._int16_array._pt = pt;
-        _values[_numValues]._int16_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_INT16_ARRAY;
-        memcpy(pt, array, len * sizeof(uint16_t));
-    }
-
-    void AddInt16ArrayRef(uint16_t *array, uint32_t len)
-    {
+    void AddInt16ArrayRef(uint16_t *array, uint32_t len) {
         EnsureFree();
         _values[_numValues]._int16_array._pt = array;
         _values[_numValues]._int16_array._len = len;
         _typeString[_numValues++] = FRT_VALUE_INT16_ARRAY;
     }
 
-    void AddInt32(uint32_t value)
-    {
+    void AddInt32(uint32_t value) {
         EnsureFree();
         _values[_numValues]._intval32 = value;
         _typeString[_numValues++] = FRT_VALUE_INT32;
     }
 
-    uint32_t *AddInt32Array(uint32_t len)
-    {
-        EnsureFree();
-        uint32_t *ret = (uint32_t *) _tub->Alloc(len * sizeof(uint32_t));
-        _values[_numValues]._int32_array._pt = ret;
-        _values[_numValues]._int32_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_INT32_ARRAY;
-        return ret;
-    }
+    uint32_t *AddInt32Array(uint32_t len);
 
-    void AddInt32Array(const uint32_t *array, uint32_t len)
-    {
-        EnsureFree();
-        uint32_t *pt = (uint32_t *) _tub->Alloc(len * sizeof(uint32_t));
-        _values[_numValues]._int32_array._pt = pt;
-        _values[_numValues]._int32_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_INT32_ARRAY;
-        memcpy(pt, array, len * sizeof(uint32_t));
-    }
+    void AddInt32Array(const uint32_t *array, uint32_t len);
 
-    void AddInt32ArrayRef(uint32_t *array, uint32_t len)
-    {
+    void AddInt32ArrayRef(uint32_t *array, uint32_t len) {
         EnsureFree();
         _values[_numValues]._int32_array._pt = array;
         _values[_numValues]._int32_array._len = len;
         _typeString[_numValues++] = FRT_VALUE_INT32_ARRAY;
     }
 
-    void AddInt64(uint64_t value)
-    {
+    void AddInt64(uint64_t value) {
         EnsureFree();
         _values[_numValues]._intval64 = value;
         _typeString[_numValues++] = FRT_VALUE_INT64;
     }
 
-    uint64_t *AddInt64Array(uint32_t len)
-    {
-        EnsureFree();
-        uint64_t *ret = (uint64_t *) _tub->Alloc(len * sizeof(uint64_t));
-        _values[_numValues]._int64_array._pt = ret;
-        _values[_numValues]._int64_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_INT64_ARRAY;
-        return ret;
-    }
-
-    void AddInt64Array(const uint64_t *array, uint32_t len)
-    {
-        EnsureFree();
-        uint64_t *pt = (uint64_t *) _tub->Alloc(len * sizeof(uint64_t));
-        _values[_numValues]._int64_array._pt = pt;
-        _values[_numValues]._int64_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_INT64_ARRAY;
-        memcpy(pt, array, len * sizeof(uint64_t));
-    }
+    uint64_t *AddInt64Array(uint32_t len);
+    void AddInt64Array(const uint64_t *array, uint32_t len);
 
-    void AddInt64ArrayRef(uint64_t *array, uint32_t len)
-    {
+    void AddInt64ArrayRef(uint64_t *array, uint32_t len) {
         EnsureFree();
         _values[_numValues]._int64_array._pt = array;
         _values[_numValues]._int64_array._len = len;
         _typeString[_numValues++] = FRT_VALUE_INT64_ARRAY;
     }
 
-    void AddFloat(float value)
-    {
+    void AddFloat(float value) {
         EnsureFree();
         _values[_numValues]._float = value;
         _typeString[_numValues++] = FRT_VALUE_FLOAT;
     }
 
-    float *AddFloatArray(uint32_t len)
-    {
-        EnsureFree();
-        float *ret = (float *) _tub->Alloc(len * sizeof(float));
-        _values[_numValues]._float_array._pt = ret;
-        _values[_numValues]._float_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_FLOAT_ARRAY;
-        return ret;
-    }
+    float *AddFloatArray(uint32_t len);
 
-    void AddFloatArray(const float *array, uint32_t len)
-    {
-        EnsureFree();
-        float *pt = (float *) _tub->Alloc(len * sizeof(float));
-        _values[_numValues]._float_array._pt = pt;
-        _values[_numValues]._float_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_FLOAT_ARRAY;
-        memcpy(pt, array, len * sizeof(float));
-    }
+    void AddFloatArray(const float *array, uint32_t len);
 
-    void AddFloatArrayRef(float *array, uint32_t len)
-    {
+    void AddFloatArrayRef(float *array, uint32_t len) {
         EnsureFree();
         _values[_numValues]._float_array._pt = array;
         _values[_numValues]._float_array._len = len;
         _typeString[_numValues++] = FRT_VALUE_FLOAT_ARRAY;
     }
 
-    void AddDouble(double value)
-    {
+    void AddDouble(double value) {
         EnsureFree();
         _values[_numValues]._double = value;
         _typeString[_numValues++] = FRT_VALUE_DOUBLE;
     }
 
-    double *AddDoubleArray(uint32_t len)
-    {
-        EnsureFree();
-        double *ret = (double *) _tub->Alloc(len * sizeof(double));
-        _values[_numValues]._double_array._pt = ret;
-        _values[_numValues]._double_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_DOUBLE_ARRAY;
-        return ret;
-    }
-
-    void AddDoubleArray(const double *array, uint32_t len)
-    {
-        EnsureFree();
-        double *pt = (double *) _tub->Alloc(len * sizeof(double));
-        _values[_numValues]._double_array._pt = pt;
-        _values[_numValues]._double_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_DOUBLE_ARRAY;
-        memcpy(pt, array, len * sizeof(double));
-    }
+    double *AddDoubleArray(uint32_t len);
+    void AddDoubleArray(const double *array, uint32_t len);
 
-    void AddDoubleArrayRef(double *array, uint32_t len)
-    {
+    void AddDoubleArrayRef(double *array, uint32_t len) {
         EnsureFree();
         _values[_numValues]._double_array._pt = array;
         _values[_numValues]._double_array._len = len;
         _typeString[_numValues++] = FRT_VALUE_DOUBLE_ARRAY;
     }
 
-    void AddString(const char *str, uint32_t len)
-    {
-        EnsureFree();
-        _values[_numValues]._string._str = _tub->CopyString(str, len);
-        _values[_numValues]._string._len = len;
-        _typeString[_numValues++] = FRT_VALUE_STRING;
-    }
-
-    void AddString(const char *str)
-    {
+    void AddString(const char *str, uint32_t len);
+    void AddString(const char *str) {
         AddString(str, strlen(str));
     }
 
-    char *AddString(uint32_t len)
-    {
-        EnsureFree();
-        char *ret = (char *) _tub->Alloc(len + 1);
-        _values[_numValues]._string._str = ret;
-        _values[_numValues]._string._len = len;
-        _typeString[_numValues++] = FRT_VALUE_STRING;
-        return ret;
-    }
-
-    FRT_StringValue *AddStringArray(uint32_t len)
-    {
-        EnsureFree();
-        FRT_StringValue *ret = (FRT_StringValue *) _tub->Alloc(len * sizeof(FRT_StringValue));
-        _values[_numValues]._string_array._pt = ret;
-        _values[_numValues]._string_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_STRING_ARRAY;
-        return ret;
-    }
-
-    void AddSharedData(FRT_ISharedBlob *blob)
-    {
-        EnsureFree();
-        _blobs = new (_tub) BlobRef(NULL, _numValues, blob, _blobs);
-        _values[_numValues]._data._buf = const_cast<char *>(blob->getData());
-        _values[_numValues]._data._len = blob->getLen();
-        _typeString[_numValues++] = FRT_VALUE_DATA;
-    }
-
-    void AddData(vespalib::alloc::Alloc buf, uint32_t len)
-    {
-        AddSharedData(new (_tub) LocalBlob(std::move(buf), len));
-    }
-
-    void AddData(const char *buf, uint32_t len)
-    {
-        if (len > FRT_MemoryTub::ALLOC_LIMIT) {
-            return AddSharedData(new (_tub) LocalBlob(buf, len));
-        }
-        EnsureFree();
-        _values[_numValues]._data._buf = _tub->CopyData(buf, len);
-        _values[_numValues]._data._len = len;
-        _typeString[_numValues++] = FRT_VALUE_DATA;
-    }
-
-    char *AddData(uint32_t len)
-    {
-        if (len > FRT_MemoryTub::ALLOC_LIMIT) {
-            LocalBlob *blob = new (_tub) LocalBlob(NULL, len);
-            AddSharedData(blob);
-            return blob->getInternalData();
-        }
-        EnsureFree();
-        char *ret = (char *) _tub->Alloc(len);
-        _values[_numValues]._data._buf = ret;
-        _values[_numValues]._data._len = len;
-        _typeString[_numValues++] = FRT_VALUE_DATA;
-        return ret;
-    }
-
-    FRT_DataValue *AddDataArray(uint32_t len)
-    {
-        EnsureFree();
-        FRT_DataValue *ret = (FRT_DataValue *) _tub->Alloc(len * sizeof(FRT_DataValue));
-        _values[_numValues]._data_array._pt = ret;
-        _values[_numValues]._data_array._len = len;
-        _typeString[_numValues++] = FRT_VALUE_DATA_ARRAY;
-        return ret;
-    }
-
-    void SetString(FRT_StringValue *value,
-                   const char *str, uint32_t len)
-    {
-        value->_str = _tub->CopyString(str, len);
-        value->_len = len;
-    }
-
-    void SetString(FRT_StringValue *value,
-                   const char *str)
-    {
-        uint32_t len = strlen(str);
-        value->_str = _tub->CopyString(str, len);
-        value->_len = len;
-    }
+    char *AddString(uint32_t len);
+    FRT_StringValue *AddStringArray(uint32_t len);
+    void AddSharedData(FRT_ISharedBlob *blob);
+    void AddData(vespalib::alloc::Alloc buf, uint32_t len);
+    void AddData(const char *buf, uint32_t len);
+    char *AddData(uint32_t len);
+    FRT_DataValue *AddDataArray(uint32_t len);
 
-    void SetData(FRT_DataValue *value,
-                 const char *buf, uint32_t len)
-    {
-        char *mybuf = NULL;
-        if (len > FRT_MemoryTub::ALLOC_LIMIT) {
-            LocalBlob *blob = new (_tub) LocalBlob(buf, len);
-            _blobs = new (_tub) BlobRef(value, 0, blob, _blobs);
-            mybuf = blob->getInternalData();
-        } else {
-            mybuf = _tub->CopyData(buf, len);
-        }
-        value->_buf = mybuf;
-        value->_len = len;
-    }
+    void SetString(FRT_StringValue *value, const char *str, uint32_t len);
+    void SetString(FRT_StringValue *value, const char *str);
+    void SetData(FRT_DataValue *value, const char *buf, uint32_t len);
 
 
     uint32_t GetNumValues() { return _numValues; }
@@ -526,11 +275,9 @@ public:
     void EncodeCopy(FNET_DataBuffer *dst);
     void EncodeBig(FNET_DataBuffer *dst);
     bool Equals(FRT_Values *values);
-    static void Print(FRT_Value value, uint32_t type,
-                      uint32_t indent = 0);
+    static void Print(FRT_Value value, uint32_t type, uint32_t indent = 0);
     static bool Equals(FRT_Value a, FRT_Value b, uint32_t type);
-    static bool Equals(FRT_Value a, uint32_t a_type,
-                       FRT_Value b, uint32_t b_type);
+    static bool Equals(FRT_Value a, uint32_t a_type, FRT_Value b, uint32_t b_type);
     static bool CheckTypes(const char *spec, const char *actual);
 };
 
diff --git a/fnet/src/vespa/fnet/info.h b/fnet/src/vespa/fnet/info.h
index 3ac46d853e0..cd293d30088 100644
--- a/fnet/src/vespa/fnet/info.h
+++ b/fnet/src/vespa/fnet/info.h
@@ -32,7 +32,7 @@ public:
     /**
      * @return true if we have support for threads
      **/
-    static bool HasThreads() { return FNET_HAS_THREADS; }
+    static bool HasThreads() { return true; }
 
     /**
      * @return the host endian (unknown/little/big)
diff --git a/fnet/src/vespa/fnet/ipacketfactory.h b/fnet/src/vespa/fnet/ipacketfactory.h
index 39d3601456d..929f95f0a0c 100644
--- a/fnet/src/vespa/fnet/ipacketfactory.h
+++ b/fnet/src/vespa/fnet/ipacketfactory.h
@@ -13,7 +13,7 @@ public:
     /**
      * Destructor.  No cleanup needed for base class.
      */
-    virtual ~FNET_IPacketFactory(void) { }
+    virtual ~FNET_IPacketFactory() { }
 
     /**
      * Create a packet.