Checkpoint 1

81 files changed, 428 insertions, 633 deletions

diff --git a/config/src/vespa/config/frt/protocol.cpp b/config/src/vespa/config/frt/protocol.cpp
index be02bc59862..5c7af53d2af 100644
--- a/config/src/vespa/config/frt/protocol.cpp
+++ b/config/src/vespa/config/frt/protocol.cpp
@@ -6,6 +6,7 @@ LOG_SETUP(".config.frt.protocol");
 #include <vespa/vespalib/util/stringfmt.h>
 
 using namespace vespalib;
+using vespalib::alloc::Alloc;
 using namespace vespalib::slime;
 
 namespace config {
@@ -58,15 +59,15 @@ const Memory RESPONSE_COMPRESSION_INFO_UNCOMPRESSED_SIZE = "uncompressedSize";
 DecompressedData
 decompress_lz4(const char * input, uint32_t inputLen, int uncompressedLength)
 {
-    DefaultAlloc::UP memory(new DefaultAlloc(uncompressedLength));
-    int sz = LZ4_decompress_safe(input, static_cast<char *>(memory->get()), inputLen, uncompressedLength);
+    Alloc memory( DefaultAlloc::create(uncompressedLength));
+    int sz = LZ4_decompress_safe(input, static_cast<char *>(memory.get()), inputLen, uncompressedLength);
     if (sz >= 0 && sz != uncompressedLength) {
         if (LOG_WOULD_LOG(debug)) {
             LOG(debug, "Returned compressed size (%d) is not the same as uncompressed size(%d)", sz, uncompressedLength);
         }
-        DefaultAlloc * copy = new DefaultAlloc(sz);
-        memcpy(copy->get(), memory->get(), sz);
-        memory.reset(copy);
+        Alloc copy = memory.create(sz);
+        memcpy(copy.get(), memory.get(), sz);
+        memory = std::move(copy);
     }
     assert(sz >= 0);
     return DecompressedData(std::move(memory), static_cast<uint32_t>(sz));
diff --git a/config/src/vespa/config/frt/protocol.h b/config/src/vespa/config/frt/protocol.h
index 79d916bf3e7..6d1c2b8226c 100644
--- a/config/src/vespa/config/frt/protocol.h
+++ b/config/src/vespa/config/frt/protocol.h
@@ -59,9 +59,9 @@ extern const vespalib::slime::Memory RESPONSE_COMPRESSION_INFO_TYPE;
 extern const vespalib::slime::Memory RESPONSE_COMPRESSION_INFO_UNCOMPRESSED_SIZE;
 
 struct DecompressedData {
-    DecompressedData(vespalib::DefaultAlloc::UP mem, uint32_t sz)
+    DecompressedData(vespalib::alloc::Alloc mem, uint32_t sz)
         : memory(std::move(mem)),
-          memRef(static_cast<const char *>(memory->get()), sz),
+          memRef(static_cast<const char *>(memory.get()), sz),
           size(sz)
     { }
     DecompressedData(const vespalib::slime::Memory & mem, uint32_t sz)
@@ -70,7 +70,7 @@ struct DecompressedData {
           size(sz)
     {}
 
-    vespalib::DefaultAlloc::UP memory;
+    vespalib::alloc::Alloc memory;
     vespalib::slime::Memory memRef;
     uint32_t size;
 };
diff --git a/document/src/vespa/document/bucket/bucketid.h b/document/src/vespa/document/bucket/bucketid.h
index f4ec15ff7c1..15d02958746 100644
--- a/document/src/vespa/document/bucket/bucketid.h
+++ b/document/src/vespa/document/bucket/bucketid.h
@@ -50,7 +50,7 @@ public:
      * typedef when needed we can alter this later with less code changes.
      */
     typedef uint64_t Type;
-    typedef vespalib::Array<BucketId, vespalib::DefaultAlloc> List;
+    typedef vespalib::Array<BucketId> List;
     /** Create an initially unset bucket id. */
     BucketId() : _id(0) {}
     /** Create a bucket id with the given raw unchecked content. */
diff --git a/document/src/vespa/document/util/bytebuffer.cpp b/document/src/vespa/document/util/bytebuffer.cpp
index 070d52ef8d9..4c8116482d5 100644
--- a/document/src/vespa/document/util/bytebuffer.cpp
+++ b/document/src/vespa/document/util/bytebuffer.cpp
@@ -21,6 +21,7 @@
 #define LOG_DEBUG3(a,b,c) LOG_DEBUG1(vespalib::make_string(a,b,c));
 #define LOG_DEBUG4(a,b,c,d) LOG_DEBUG1(vespalib::make_string(a,b,c,d));
 
+using vespalib::alloc::Alloc;
 using vespalib::DefaultAlloc;
 
 namespace document {
@@ -59,7 +60,7 @@ ByteBuffer::ByteBuffer() :
 }
 
 ByteBuffer::ByteBuffer(size_t len) :
-    ByteBuffer(DefaultAlloc(len), len)
+    ByteBuffer(DefaultAlloc::create(len), len)
 {
 }
 
@@ -74,7 +75,7 @@ ByteBuffer::ByteBuffer(const char* buffer, size_t len) :
     set(buffer, len);
 }
 
-ByteBuffer::ByteBuffer(DefaultAlloc buffer, size_t len) :
+ByteBuffer::ByteBuffer(Alloc buffer, size_t len) :
       _buffer(static_cast<char *>(buffer.get())),
       _len(len),
       _pos(0),
@@ -114,7 +115,7 @@ ByteBuffer& ByteBuffer::operator=(const ByteBuffer & org)
     if (this != & org) {
         cleanUp();
         if (org._len > 0 && org._buffer) {
-            DefaultAlloc(org._len + 1).swap(_ownedBuffer);
+            DefaultAlloc::create(org._len + 1).swap(_ownedBuffer);
             _buffer = static_cast<char *>(_ownedBuffer.get());
             memcpy(_buffer,org._buffer,org._len);
             _buffer[org._len] = 0;
@@ -189,7 +190,7 @@ ByteBuffer::sliceFrom(const ByteBuffer& buf, size_t from, size_t to) // throw (B
         // Slicing from someone that doesn't own their buffer, must make own copy.
         if (( buf._ownedBuffer.get() == NULL ) && (buf._bufHolder == NULL)) {
             cleanUp();
-            DefaultAlloc(to-from + 1).swap(_ownedBuffer);
+            DefaultAlloc::create(to-from + 1).swap(_ownedBuffer);
             _buffer = static_cast<char *>(_ownedBuffer.get());
             memcpy(_buffer, buf._buffer + from, to-from);
             _buffer[to-from] = 0;
@@ -200,7 +201,7 @@ ByteBuffer::sliceFrom(const ByteBuffer& buf, size_t from, size_t to) // throw (B
 
         // Slicing from someone that owns, but hasn't made a reference counter yet.
         if (!buf._bufHolder) {
-            buf._bufHolder=new BufferHolder(std::move(const_cast<DefaultAlloc &>(buf._ownedBuffer)));
+            buf._bufHolder=new BufferHolder(std::move(const_cast<Alloc &>(buf._ownedBuffer)));
         }
 
         // Slicing from refcounter.
@@ -218,7 +219,7 @@ ByteBuffer::sliceFrom(const ByteBuffer& buf, size_t from, size_t to) // throw (B
 ByteBuffer* ByteBuffer::copyBuffer(const char* buffer, size_t len)
 {
     if (buffer && len) {
-        DefaultAlloc newBuf(len + 1);
+        Alloc newBuf = DefaultAlloc::create(len + 1);
         memcpy(newBuf.get(), buffer, len);
         static_cast<char *>(newBuf.get())[len] = 0;
         return new ByteBuffer(std::move(newBuf), len);
@@ -265,7 +266,7 @@ void ByteBuffer::flip()
 }
 
 
-ByteBuffer::BufferHolder::BufferHolder(DefaultAlloc buffer)
+ByteBuffer::BufferHolder::BufferHolder(Alloc buffer)
     : _buffer(std::move(buffer))
 {
 }
@@ -753,7 +754,7 @@ void ByteBuffer::cleanUp() {
         _bufHolder->subRef();
         _bufHolder = NULL;
     } else {
-        DefaultAlloc().swap(_ownedBuffer);
+        Alloc().swap(_ownedBuffer);
     }
     _buffer = NULL;
 }
diff --git a/document/src/vespa/document/util/bytebuffer.h b/document/src/vespa/document/util/bytebuffer.h
index cfb72e092a5..9207d47350d 100644
--- a/document/src/vespa/document/util/bytebuffer.h
+++ b/document/src/vespa/document/util/bytebuffer.h
@@ -73,7 +73,7 @@ public:
      * @param buffer The buffer to represent.
      * @param len The length of the buffer
      */
-    ByteBuffer(vespalib::DefaultAlloc buffer, size_t len);
+    ByteBuffer(vespalib::alloc::Alloc buffer, size_t len);
 
     /**
      * Sets the buffer pointed to by this buffer. Allows for multiple
@@ -393,10 +393,10 @@ public:
         BufferHolder& operator=(const BufferHolder &);
 
     public:
-        BufferHolder(vespalib::DefaultAlloc buffer);
+        BufferHolder(vespalib::alloc::Alloc buffer);
         virtual ~BufferHolder();
 
-        vespalib::DefaultAlloc _buffer;
+        vespalib::alloc::Alloc _buffer;
     };
 
     ByteBuffer(BufferHolder* buf, size_t pos, size_t len, size_t limit);
@@ -409,7 +409,7 @@ private:
     size_t _pos;
     size_t _limit;
     mutable BufferHolder   * _bufHolder;
-    vespalib::DefaultAlloc _ownedBuffer;
+    vespalib::alloc::Alloc _ownedBuffer;
 public:
 
     std::string toString();
diff --git a/document/src/vespa/document/util/compressor.cpp b/document/src/vespa/document/util/compressor.cpp
index f11283c7c40..9f0c6913325 100644
--- a/document/src/vespa/document/util/compressor.cpp
+++ b/document/src/vespa/document/util/compressor.cpp
@@ -11,6 +11,12 @@ LOG_SETUP(".document.compressor");
 #include <lz4.h>
 #include <lz4hc.h>
 
+using vespalib::alloc::Alloc;
+using vespalib::DefaultAlloc;
+using vespalib::ConstBufferRef;
+using vespalib::DataBuffer;
+using vespalib::make_string;
+
 namespace document
 {
 
@@ -24,10 +30,10 @@ LZ4Compressor::process(const CompressionConfig& config, const void * inputV, siz
     char * output(static_cast<char *>(outputV));
     int sz(-1);
     if (config.compressionLevel > 6) {
-        vespalib::DefaultAlloc state(LZ4_sizeofStateHC());
+        Alloc state = DefaultAlloc::create(LZ4_sizeofStateHC());
         sz = LZ4_compressHC2_withStateHC(state.get(), input, output, inputLen, config.compressionLevel);
     } else {
-        vespalib::DefaultAlloc state(LZ4_sizeofState());
+        Alloc state = DefaultAlloc::create(LZ4_sizeofState());
         sz = LZ4_compress_withState(state.get(), input, output, inputLen);
     }
     if (sz != 0) {
@@ -52,7 +58,7 @@ LZ4Compressor::unprocess(const void * inputV, size_t inputLen, void * outputV, s
 }
 
 CompressionConfig::Type
-compress(ICompressor & compressor, const CompressionConfig & compression, const vespalib::ConstBufferRef & org, vespalib::DataBuffer & dest)
+compress(ICompressor & compressor, const CompressionConfig & compression, const ConstBufferRef & org, DataBuffer & dest)
 {
     CompressionConfig::Type type(CompressionConfig::NONE);
     dest.ensureFree(compressor.adjustProcessLen(0, org.size()));
@@ -67,7 +73,7 @@ compress(ICompressor & compressor, const CompressionConfig & compression, const
 }
 
 CompressionConfig::Type
-docompress(const CompressionConfig & compression, const vespalib::ConstBufferRef & org, vespalib::DataBuffer & dest)
+docompress(const CompressionConfig & compression, const ConstBufferRef & org, DataBuffer & dest)
 {
     CompressionConfig::Type type(CompressionConfig::NONE);
     switch (compression.type) {
@@ -85,7 +91,7 @@ docompress(const CompressionConfig & compression, const vespalib::ConstBufferRef
 }
 
 CompressionConfig::Type
-compress(const CompressionConfig & compression, const vespalib::ConstBufferRef & org, vespalib::DataBuffer & dest, bool allowSwap)
+compress(const CompressionConfig & compression, const ConstBufferRef & org, DataBuffer & dest, bool allowSwap)
 {
     CompressionConfig::Type type(CompressionConfig::NONE);
     if (org.size() >= compression.minSize) {
@@ -93,7 +99,7 @@ compress(const CompressionConfig & compression, const vespalib::ConstBufferRef &
     }
     if (type == CompressionConfig::NONE) {
         if (allowSwap) {
-            vespalib::DataBuffer tmp(const_cast<char *>(org.c_str()), org.size());
+            DataBuffer tmp(const_cast<char *>(org.c_str()), org.size());
             tmp.moveFreeToData(org.size());
             dest.swap(tmp);
         } else {
@@ -105,27 +111,22 @@ compress(const CompressionConfig & compression, const vespalib::ConstBufferRef &
 
 
 void
-decompress(ICompressor & decompressor, size_t uncompressedLen, const vespalib::ConstBufferRef & org, vespalib::DataBuffer & dest, bool allowSwap)
+decompress(ICompressor & decompressor, size_t uncompressedLen, const ConstBufferRef & org, DataBuffer & dest, bool allowSwap)
 {
     dest.ensureFree(uncompressedLen);
     size_t realUncompressedLen(dest.getFreeLen());
     if ( ! decompressor.unprocess(org.c_str(), org.size(), dest.getFree(), realUncompressedLen) ) {
         if ( uncompressedLen < realUncompressedLen) {
             if (allowSwap) {
-                vespalib::DataBuffer tmp(const_cast<char *>(org.c_str()), org.size());
+                DataBuffer tmp(const_cast<char *>(org.c_str()), org.size());
                 tmp.moveFreeToData(org.size());
                 dest.swap(tmp);
             } else {
                 dest.writeBytes(org.c_str(), org.size());
             }
         } else {
-            throw std::runtime_error(
-                vespalib::make_string("unprocess failed had %" PRIu64
-                                      ", wanted %" PRId64
-                                      ", got %" PRIu64,
-                                      org.size(),
-                                      uncompressedLen,
-                                      realUncompressedLen));
+            throw std::runtime_error(make_string("unprocess failed had %" PRIu64 ", wanted %" PRId64 ", got %" PRIu64,
+                                                 org.size(), uncompressedLen, realUncompressedLen));
         }
     } else {
         dest.moveFreeToData(realUncompressedLen);
@@ -133,7 +134,7 @@ decompress(ICompressor & decompressor, size_t uncompressedLen, const vespalib::C
 }
 
 void
-decompress(const CompressionConfig::Type & type, size_t uncompressedLen, const vespalib::ConstBufferRef & org, vespalib::DataBuffer & dest, bool allowSwap)
+decompress(const CompressionConfig::Type & type, size_t uncompressedLen, const ConstBufferRef & org, DataBuffer & dest, bool allowSwap)
 {
     switch (type) {
     case CompressionConfig::LZ4:
@@ -145,7 +146,7 @@ decompress(const CompressionConfig::Type & type, size_t uncompressedLen, const v
     case CompressionConfig::NONE:
     case CompressionConfig::UNCOMPRESSABLE:
         if (allowSwap) {
-            vespalib::DataBuffer tmp(const_cast<char *>(org.c_str()), org.size());
+            DataBuffer tmp(const_cast<char *>(org.c_str()), org.size());
             tmp.moveFreeToData(org.size());
             dest.swap(tmp);
         } else {
@@ -153,7 +154,7 @@ decompress(const CompressionConfig::Type & type, size_t uncompressedLen, const v
         }
         break;
     default:
-        throw std::runtime_error(vespalib::make_string("Unable to handle decompression of type '%d'", type));
+        throw std::runtime_error(make_string("Unable to handle decompression of type '%d'", type));
         break;
     }
 }
diff --git a/fastlib/src/vespa/fastlib/io/bufferedfile.cpp b/fastlib/src/vespa/fastlib/io/bufferedfile.cpp
index 84eb8534cda..adf201a6e1e 100644
--- a/fastlib/src/vespa/fastlib/io/bufferedfile.cpp
+++ b/fastlib/src/vespa/fastlib/io/bufferedfile.cpp
@@ -392,7 +392,7 @@ size_t computeBufLen(size_t buflen)
 Fast_BufferedFile::Fast_BufferedFile(FastOS_FileInterface *file, size_t bufferSize) :
     FastOS_FileInterface(),
     _fileleft(static_cast<uint64_t>(-1)),
-    _buf(computeBufLen(bufferSize)),
+    _buf(vespalib::alloc::MMapAllocFactory::create(computeBufLen(bufferSize))),
     _bufi(NULL),
     _bufe(NULL),
     _filepos(0),
diff --git a/fastlib/src/vespa/fastlib/io/bufferedfile.h b/fastlib/src/vespa/fastlib/io/bufferedfile.h
index 275e066a849..7443b325dd4 100644
--- a/fastlib/src/vespa/fastlib/io/bufferedfile.h
+++ b/fastlib/src/vespa/fastlib/io/bufferedfile.h
@@ -23,7 +23,7 @@
 class Fast_BufferedFile : public FastOS_FileInterface, public vespalib::noncopyable
 {
 private:
-    typedef vespalib::MMapAlloc Alloc;
+    using Alloc = vespalib::alloc::Alloc;
     /** The number of bytes left in the file. */
     int64_t _fileleft;
     /** Pointer to the start of the buffer. Correctly aligned for direct IO */
diff --git a/fnet/src/vespa/fnet/databuffer.cpp b/fnet/src/vespa/fnet/databuffer.cpp
index 3239dbf5087..913196d6e72 100644
--- a/fnet/src/vespa/fnet/databuffer.cpp
+++ b/fnet/src/vespa/fnet/databuffer.cpp
@@ -15,7 +15,7 @@ FNET_DataBuffer::FNET_DataBuffer(uint32_t len)
         len = 256;
 
     if (len > 0) {
-       DefaultAlloc(len).swap(_ownedBuf);
+       DefaultAlloc::create(len).swap(_ownedBuf);
        memset(_ownedBuf.get(), 0x55, len);
         _bufstart = static_cast<char *>(_ownedBuf.get());
         assert(_bufstart != NULL);
@@ -72,7 +72,7 @@ FNET_DataBuffer::Shrink(uint32_t newsize)
         return false;
     }
     
-    DefaultAlloc newBuf(newsize);
+    Alloc newBuf(DefaultAlloc::create(newsize));
     memset(newBuf.get(), 0x55, newsize);
     memcpy(newBuf.get(), _datapt, GetDataLen());
     _ownedBuf.swap(newBuf);
@@ -97,7 +97,7 @@ FNET_DataBuffer::Pack(uint32_t needbytes)
         while (bufsize - GetDataLen() < needbytes)
             bufsize *= 2;
 
-        DefaultAlloc newBuf(bufsize);
+        Alloc newBuf(DefaultAlloc::create(bufsize));
         memset(newBuf.get(), 0x55, bufsize);
         memcpy(newBuf.get(), _datapt, GetDataLen());
         _ownedBuf.swap(newBuf);
diff --git a/fnet/src/vespa/fnet/databuffer.h b/fnet/src/vespa/fnet/databuffer.h
index 23802d2ea90..8e4127d3b72 100644
--- a/fnet/src/vespa/fnet/databuffer.h
+++ b/fnet/src/vespa/fnet/databuffer.h
@@ -29,11 +29,12 @@
 class FNET_DataBuffer
 {
 private:
-    char          *_bufstart;
-    char          *_bufend;
-    char          *_datapt;
-    char          *_freept;
-    vespalib::DefaultAlloc _ownedBuf;
+    using Alloc = vespalib::alloc::Alloc;
+    char  *_bufstart;
+    char  *_bufend;
+    char  *_datapt;
+    char  *_freept;
+    Alloc  _ownedBuf;
 
     FNET_DataBuffer(const FNET_DataBuffer &);
     FNET_DataBuffer &operator=(const FNET_DataBuffer &);
diff --git a/fnet/src/vespa/fnet/frt/values.h b/fnet/src/vespa/fnet/frt/values.h
index 0c3b13b16f3..8ab8914d31f 100644
--- a/fnet/src/vespa/fnet/frt/values.h
+++ b/fnet/src/vespa/fnet/frt/values.h
@@ -72,12 +72,12 @@ public:
     class LocalBlob : public FRT_ISharedBlob
     {
     public:
-        LocalBlob(vespalib::DefaultAlloc data, uint32_t len) :
+        LocalBlob(vespalib::alloc::Alloc data, uint32_t len) :
             _data(std::move(data)),
             _len(len)
         { }
         LocalBlob(const char *data, uint32_t len) :
-            _data(len),
+            _data(vespalib::DefaultAlloc::create(len)),
             _len(len)
         {
             if (data != NULL) {
@@ -85,7 +85,7 @@ public:
             }
         }
         void addRef() override {}
-        void subRef() override { vespalib::DefaultAlloc().swap(_data); }
+        void subRef() override { vespalib::alloc::Alloc().swap(_data); }
         uint32_t getLen() override { return _len; }
         const char *getData() override { return static_cast<const char *>(_data.get()); }
         char *getInternalData() { return static_cast<char *>(_data.get()); }
@@ -93,7 +93,7 @@ public:
         LocalBlob(const LocalBlob &);
         LocalBlob &operator=(const LocalBlob &);
 
-        vespalib::DefaultAlloc _data;
+        vespalib::alloc::Alloc _data;
         uint32_t _len;
     };
 
@@ -439,7 +439,7 @@ public:
         _typeString[_numValues++] = FRT_VALUE_DATA;
     }
 
-    void AddData(vespalib::DefaultAlloc buf, uint32_t len)
+    void AddData(vespalib::alloc::Alloc buf, uint32_t len)
     {
         AddSharedData(new (_tub) LocalBlob(std::move(buf), len));
     }
diff --git a/memfilepersistence/src/tests/spi/buffer_test.cpp b/memfilepersistence/src/tests/spi/buffer_test.cpp
index a2d917301fc..fdbd7a32f17 100644
--- a/memfilepersistence/src/tests/spi/buffer_test.cpp
+++ b/memfilepersistence/src/tests/spi/buffer_test.cpp
@@ -36,9 +36,8 @@ BufferTest::getSizeReturnsInitiallyAllocatedSize()
 void
 BufferTest::getSizeReturnsUnAlignedSizeForMMappedAllocs()
 {
-    Buffer buf(vespalib::MMapAlloc::HUGEPAGE_SIZE + 1);
-    CPPUNIT_ASSERT_EQUAL(size_t(vespalib::MMapAlloc::HUGEPAGE_SIZE + 1),
-                         buf.getSize());
+    Buffer buf(vespalib::alloc::MMapAllocator::HUGEPAGE_SIZE + 1);
+    CPPUNIT_ASSERT_EQUAL(size_t(vespalib::alloc::MMapAllocator::HUGEPAGE_SIZE + 1), buf.getSize());
 }
 
 void
diff --git a/memfilepersistence/src/vespa/memfilepersistence/mapper/buffer.cpp b/memfilepersistence/src/vespa/memfilepersistence/mapper/buffer.cpp
index 5ecb439b3f0..886c2a35c13 100644
--- a/memfilepersistence/src/vespa/memfilepersistence/mapper/buffer.cpp
+++ b/memfilepersistence/src/vespa/memfilepersistence/mapper/buffer.cpp
@@ -5,11 +5,18 @@
 #include <algorithm>
 #include <stdlib.h>
 
+using vespalib::DefaultAlloc;
+using vespalib::alloc::MMapAllocator;
+using vespalib::alloc::Alloc;
+
 namespace storage {
 namespace memfile {
 
+// Use AutoAlloc to transparently use mmap for large buffers.
+// It is crucial that any backing buffer type returns an address that is
+// 512-byte aligned, or direct IO will scream at us and fail everything.
 Buffer::Buffer(size_t size)
-    : _buffer(size),
+    : _buffer(DefaultAlloc::create(size, MMapAllocator::HUGEPAGE_SIZE, 512)),
       _size(size)
 {
 }
@@ -17,7 +24,7 @@ Buffer::Buffer(size_t size)
 void
 Buffer::resize(size_t size)
 {
-    BackingType buffer(size);
+    Alloc buffer = _buffer.create(size);
     size_t commonSize(std::min(size, _size));
     memcpy(buffer.get(), _buffer.get(), commonSize);
     _buffer.swap(buffer);
diff --git a/memfilepersistence/src/vespa/memfilepersistence/mapper/buffer.h b/memfilepersistence/src/vespa/memfilepersistence/mapper/buffer.h
index d097a078af9..26f4a644d0c 100644
--- a/memfilepersistence/src/vespa/memfilepersistence/mapper/buffer.h
+++ b/memfilepersistence/src/vespa/memfilepersistence/mapper/buffer.h
@@ -19,13 +19,7 @@ namespace memfile {
 
 class Buffer
 {
-    // Use AutoAlloc to transparently use mmap for large buffers.
-    // It is crucial that any backing buffer type returns an address that is
-    // 512-byte aligned, or direct IO will scream at us and fail everything.
-    static constexpr size_t MMapLimit = vespalib::MMapAlloc::HUGEPAGE_SIZE;
-    using BackingType = vespalib::AutoAlloc<MMapLimit, 512>;
-
-    BackingType _buffer;
+    vespalib::alloc::Alloc _buffer;
     // Actual, non-aligned size (as opposed to _buffer.size()).
     size_t _size;
 
diff --git a/memfilepersistence/src/vespa/memfilepersistence/mapper/simplememfileiobuffer.h b/memfilepersistence/src/vespa/memfilepersistence/mapper/simplememfileiobuffer.h
index 8dbffcaf795..c564893a154 100644
--- a/memfilepersistence/src/vespa/memfilepersistence/mapper/simplememfileiobuffer.h
+++ b/memfilepersistence/src/vespa/memfilepersistence/mapper/simplememfileiobuffer.h
@@ -77,7 +77,7 @@ public:
 
         typedef vespalib::LinkedPtr<SharedBuffer> LP;
         explicit SharedBuffer(size_t totalSize)
-            : _buf(totalSize),
+            : _buf(vespalib::alloc::MMapAllocFactory::create(totalSize)),
               _usedSize(0)
         {
         }
@@ -115,7 +115,7 @@ public:
             return static_cast<const char*>(_buf.get());
         }
     private:
-        vespalib::MMapAlloc _buf;
+        vespalib::alloc::Alloc _buf;
         size_t _usedSize;
     };
 
diff --git a/messagebus/src/vespa/messagebus/blob.h b/messagebus/src/vespa/messagebus/blob.h
index 101ea989a92..86e317d6e79 100644
--- a/messagebus/src/vespa/messagebus/blob.h
+++ b/messagebus/src/vespa/messagebus/blob.h
@@ -22,7 +22,7 @@ public:
      * @param s size of the data to be created
      **/
     Blob(uint32_t s) :
-        _payload(s),
+        _payload(vespalib::DefaultAlloc::create(s)),
         _sz(s)
     { }
     Blob(Blob && rhs) :
@@ -55,11 +55,11 @@ public:
      **/
     const char *data() const { return static_cast<const char *>(_payload.get()); }
 
-    vespalib::DefaultAlloc & payload() { return _payload; }
-    const vespalib::DefaultAlloc & payload() const { return _payload; }
+    vespalib::alloc::Alloc & payload() { return _payload; }
+    const vespalib::alloc::Alloc & payload() const { return _payload; }
     size_t size() const { return _sz; }
 private:
-    vespalib::DefaultAlloc _payload;
+    vespalib::alloc::Alloc _payload;
     size_t _sz;
 };
 
diff --git a/searchlib/src/vespa/searchlib/attribute/changevector.h b/searchlib/src/vespa/searchlib/attribute/changevector.h
index a714e502588..90a8ff7e2d4 100644
--- a/searchlib/src/vespa/searchlib/attribute/changevector.h
+++ b/searchlib/src/vespa/searchlib/attribute/changevector.h
@@ -140,7 +140,7 @@ template <typename T>
 class ChangeVectorT : public ChangeVectorBase {
 private:
     typedef vespalib::hash_map<uint32_t, uint32_t> Map;
-    typedef vespalib::Array<T, vespalib::DefaultAlloc> Vector;
+    typedef vespalib::Array<T> Vector;
 public:
     ChangeVectorT() : _tail(0) { } 
     class const_iterator {
diff --git a/searchlib/src/vespa/searchlib/attribute/enumstore.h b/searchlib/src/vespa/searchlib/attribute/enumstore.h
index 0f0675248a7..18bb676644e 100644
--- a/searchlib/src/vespa/searchlib/attribute/enumstore.h
+++ b/searchlib/src/vespa/searchlib/attribute/enumstore.h
@@ -154,7 +154,7 @@ public:
             uint32_t _refCount;
         };
 
-        typedef vespalib::Array<UniqueEntry, vespalib::DefaultAlloc> Uniques;
+        typedef vespalib::Array<UniqueEntry> Uniques;
     private:
         Uniques _uniques;
         uint64_t _bufferSize;
diff --git a/searchlib/src/vespa/searchlib/attribute/enumstorebase.h b/searchlib/src/vespa/searchlib/attribute/enumstorebase.h
index 3b8b9823d87..4c2d35d645f 100644
--- a/searchlib/src/vespa/searchlib/attribute/enumstorebase.h
+++ b/searchlib/src/vespa/searchlib/attribute/enumstorebase.h
@@ -34,8 +34,8 @@ class EnumStoreComparatorWrapper;
 typedef btree::DataStoreT<btree::AlignedEntryRefT<31, 4> >
 EnumStoreDataStoreType;
 typedef EnumStoreDataStoreType::RefType EnumStoreIndex;
-typedef vespalib::Array<EnumStoreIndex, vespalib::DefaultAlloc> EnumStoreIndexVector;
-typedef vespalib::Array<uint32_t, vespalib::DefaultAlloc> EnumStoreEnumVector;
+typedef vespalib::Array<EnumStoreIndex> EnumStoreIndexVector;
+typedef vespalib::Array<uint32_t> EnumStoreEnumVector;
 
 typedef btree::BTreeTraits<32, 32, 7, true> EnumTreeTraits;
 
diff --git a/searchlib/src/vespa/searchlib/attribute/iattributefilewriter.h b/searchlib/src/vespa/searchlib/attribute/iattributefilewriter.h
index ec0fbf8e6a4..d2d5cb86cf5 100644
--- a/searchlib/src/vespa/searchlib/attribute/iattributefilewriter.h
+++ b/searchlib/src/vespa/searchlib/attribute/iattributefilewriter.h
@@ -16,7 +16,7 @@ class BufferWriter;
 class IAttributeFileWriter
 {
 public:
-    using BufferBuf = vespalib::MMapDataBuffer;
+    using BufferBuf = vespalib::DataBuffer;
     using Buffer = std::unique_ptr<BufferBuf>;
 
     virtual ~IAttributeFileWriter() = default;
diff --git a/searchlib/src/vespa/searchlib/attribute/loadedenumvalue.h b/searchlib/src/vespa/searchlib/attribute/loadedenumvalue.h
index 47b7eab1b83..749247b0e78 100644
--- a/searchlib/src/vespa/searchlib/attribute/loadedenumvalue.h
+++ b/searchlib/src/vespa/searchlib/attribute/loadedenumvalue.h
@@ -94,7 +94,7 @@ public:
     }
 };
     
-typedef vespalib::Array<LoadedEnumAttribute, vespalib::DefaultAlloc> LoadedEnumAttributeVector;
+typedef vespalib::Array<LoadedEnumAttribute> LoadedEnumAttributeVector;
 
 
 /**
diff --git a/searchlib/src/vespa/searchlib/attribute/loadednumericvalue.h b/searchlib/src/vespa/searchlib/attribute/loadednumericvalue.h
index a8855ba5f15..23b6f02d2fa 100644
--- a/searchlib/src/vespa/searchlib/attribute/loadednumericvalue.h
+++ b/searchlib/src/vespa/searchlib/attribute/loadednumericvalue.h
@@ -6,12 +6,9 @@
 #include <vespa/searchlib/util/fileutil.h>
 #include "loadedvalue.h"
 
+namespace search {
 
-namespace search
-{
-
-namespace attribute
-{
+namespace attribute {
 
 /**
  * Temporary representation of enumerated attribute loaded from non-enumerated
@@ -21,20 +18,12 @@ namespace attribute
 template <typename T>
 struct LoadedNumericValue : public LoadedValue<T>
 {
-    LoadedNumericValue()
-        : LoadedValue<T>()
-    {
-    }
+    LoadedNumericValue() : LoadedValue<T>() { }
 
-    class ValueCompare : public std::binary_function<LoadedNumericValue<T>,
-                                                     LoadedNumericValue<T>,
-                                                     bool>
+    class ValueCompare : public std::binary_function<LoadedNumericValue<T>, LoadedNumericValue<T>, bool>
     {
     public:
-        bool
-        operator()(const LoadedNumericValue<T> &x,
-                   const LoadedNumericValue<T> &y) const
-        {
+        bool operator()(const LoadedNumericValue<T> &x, const LoadedNumericValue<T> &y) const {
             return x < y;
         }
     };
@@ -42,9 +31,7 @@ struct LoadedNumericValue : public LoadedValue<T>
     class ValueRadix
     {
     public:
-        uint64_t
-        operator()(const LoadedValue<T> &v) const
-        {
+        uint64_t operator()(const LoadedValue<T> &v) const {
             return vespalib::convertForSort<T, true>::convert(v.getValue());
         }
     };
@@ -53,15 +40,11 @@ struct LoadedNumericValue : public LoadedValue<T>
 
 template <typename T>
 void
-sortLoadedByValue(SequentialReadModifyWriteVector<LoadedNumericValue<T>,
-                                                  vespalib::DefaultAlloc> &
-                  loaded);
+sortLoadedByValue(SequentialReadModifyWriteVector<LoadedNumericValue<T>> & loaded);
 
 template <typename T>
 void
-sortLoadedByDocId(SequentialReadModifyWriteVector<LoadedNumericValue<T>,
-                  vespalib::DefaultAlloc> &
-                  loaded);
+sortLoadedByDocId(SequentialReadModifyWriteVector<LoadedNumericValue<T>> & loaded);
 
 } // namespace attribute
 
diff --git a/searchlib/src/vespa/searchlib/attribute/loadedstringvalue.cpp b/searchlib/src/vespa/searchlib/attribute/loadedstringvalue.cpp
index 335abb799b0..478b7a5e7a9 100644
--- a/searchlib/src/vespa/searchlib/attribute/loadedstringvalue.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/loadedstringvalue.cpp
@@ -3,18 +3,17 @@
 #include <vespa/fastos/fastos.h>
 #include "loadedstringvalue.h"
 
+using vespalib::Array;
+using vespalib::alloc::MMapAllocFactory;
 
-namespace search
-{
+namespace search {
 
-namespace attribute
-{
+namespace attribute {
 
 void
 sortLoadedByValue(LoadedStringVectorReal &loaded)
 {
-    vespalib::Array<unsigned, vespalib::MMapAlloc>
-        radixScratchPad(loaded.size());
+    Array<unsigned> radixScratchPad(loaded.size(), MMapAllocFactory::create());
     for(size_t i(0), m(loaded.size()); i < m; i++) {
         loaded[i].prepareRadixSort();
     }
diff --git a/searchlib/src/vespa/searchlib/attribute/loadedstringvalue.h b/searchlib/src/vespa/searchlib/attribute/loadedstringvalue.h
index 87e2574bdb6..15a29096e20 100644
--- a/searchlib/src/vespa/searchlib/attribute/loadedstringvalue.h
+++ b/searchlib/src/vespa/searchlib/attribute/loadedstringvalue.h
@@ -78,7 +78,7 @@ typedef RadixSortable<LoadedValue<const char *> > LoadedStringValue;
 
 typedef SequentialReadModifyWriteInterface<LoadedStringValue> LoadedStringVector;
 
-typedef SequentialReadModifyWriteVector<LoadedStringValue, vespalib::DefaultAlloc>
+typedef SequentialReadModifyWriteVector<LoadedStringValue>
 LoadedStringVectorReal;
 
 
diff --git a/searchlib/src/vespa/searchlib/attribute/multinumericenumattribute.h b/searchlib/src/vespa/searchlib/attribute/multinumericenumattribute.h
index 8ef3d28549b..fae23b72dba 100644
--- a/searchlib/src/vespa/searchlib/attribute/multinumericenumattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/multinumericenumattribute.h
@@ -29,7 +29,7 @@ protected:
     typedef typename B::BaseClass::largeint_t      largeint_t;
     typedef typename B::BaseClass::LoadedNumericValueT LoadedNumericValueT;
     typedef typename B::BaseClass::LoadedVector    LoadedVector;
-    typedef SequentialReadModifyWriteVector<LoadedNumericValueT, vespalib::DefaultAlloc> LoadedVectorR;
+    typedef SequentialReadModifyWriteVector<LoadedNumericValueT> LoadedVectorR;
     typedef typename B::BaseClass::Weighted        Weighted;
     typedef typename B::BaseClass::WeightedInt     WeightedInt;
     typedef typename B::BaseClass::WeightedFloat   WeightedFloat;
diff --git a/searchlib/src/vespa/searchlib/attribute/multivaluemapping.h b/searchlib/src/vespa/searchlib/attribute/multivaluemapping.h
index 3134f826774..c73ec38bcfe 100644
--- a/searchlib/src/vespa/searchlib/attribute/multivaluemapping.h
+++ b/searchlib/src/vespa/searchlib/attribute/multivaluemapping.h
@@ -236,7 +236,7 @@ private:
     virtual void clearVector(Index idx) = 0;
 
 public:
-    using IndexCopyVector = vespalib::Array<Index, vespalib::DefaultAlloc>;
+    using IndexCopyVector = vespalib::Array<Index>;
 
     void
     doneHoldVector(Index idx);
@@ -330,11 +330,11 @@ public:
 
 
 template <typename VT>
-class MultiValueMappingVector : public vespalib::Array<VT, vespalib::DefaultAlloc>,
+class MultiValueMappingVector : public vespalib::Array<VT>,
                                 public MultiValueMappingVectorBaseBase
 {
 public:
-    typedef vespalib::Array<VT, vespalib::DefaultAlloc> VectorBase;
+    typedef vespalib::Array<VT> VectorBase;
     typedef MultiValueMappingFallbackVectorHold<VectorBase> FallBackHold;
     MultiValueMappingVector();
     MultiValueMappingVector(uint32_t n);
diff --git a/searchlib/src/vespa/searchlib/attribute/postingchange.h b/searchlib/src/vespa/searchlib/attribute/postingchange.h
index b4abe0c7dd2..d728fa89fb0 100644
--- a/searchlib/src/vespa/searchlib/attribute/postingchange.h
+++ b/searchlib/src/vespa/searchlib/attribute/postingchange.h
@@ -18,7 +18,7 @@ template <typename P>
 class PostingChange
 {
 public:
-    typedef vespalib::Array<P, vespalib::DefaultAlloc> A;
+    typedef vespalib::Array<P> A;
     typedef std::vector<uint32_t> R;
     A _additions;
     R _removals;
diff --git a/searchlib/src/vespa/searchlib/attribute/postinglistattribute.cpp b/searchlib/src/vespa/searchlib/attribute/postinglistattribute.cpp
index 2d79e80142a..847071cf4f4 100644
--- a/searchlib/src/vespa/searchlib/attribute/postinglistattribute.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/postinglistattribute.cpp
@@ -237,8 +237,7 @@ handleFillPostings(LoadedVector &loaded)
     uint32_t docIdLimit = _attr.getNumDocs();
     _postingList.resizeBitVectors(docIdLimit, docIdLimit);
     if ( ! loaded.empty() ) {
-        vespalib::Array<typename LoadedVector::Type,
-            vespalib::DefaultAlloc> similarValues;
+        vespalib::Array<typename LoadedVector::Type> similarValues;
         typename LoadedVector::Type v = loaded.read();
         LoadedValueType prev = v.getValue();
         for(size_t i(0), m(loaded.size()); i < m; i++, loaded.next()) {
diff --git a/searchlib/src/vespa/searchlib/attribute/predicate_attribute.cpp b/searchlib/src/vespa/searchlib/attribute/predicate_attribute.cpp
index a0693755666..620188d9630 100644
--- a/searchlib/src/vespa/searchlib/attribute/predicate_attribute.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/predicate_attribute.cpp
@@ -13,7 +13,7 @@ LOG_SETUP(".predicate_attribute");
 
 using document::Predicate;
 using document::PredicateFieldValue;
-using vespalib::MMapDataBuffer;
+using vespalib::DataBuffer;
 using namespace search::predicate;
 
 namespace search {
@@ -181,7 +181,7 @@ bool PredicateAttribute::onLoad()
     FileUtil::LoadedBuffer::UP loaded_buffer = loadDAT();
     char *rawBuffer = const_cast<char *>(static_cast<const char *>(loaded_buffer->buffer()));
     size_t size = loaded_buffer->size();
-    MMapDataBuffer buffer(rawBuffer, size);
+    DataBuffer buffer(rawBuffer, size);
     buffer.moveFreeToData(size);
 
     const GenericHeader &header = loaded_buffer->getHeader();
diff --git a/searchlib/src/vespa/searchlib/attribute/singleenumattribute.h b/searchlib/src/vespa/searchlib/attribute/singleenumattribute.h
index ad0cc2a98a3..4768928603b 100644
--- a/searchlib/src/vespa/searchlib/attribute/singleenumattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/singleenumattribute.h
@@ -24,8 +24,7 @@ protected:
     typedef vespalib::GenerationHolder GenerationHolder;
 
 public:
-    using EnumIndexCopyVector = vespalib::Array<EnumIndex,
-                                                vespalib::DefaultAlloc>;
+    using EnumIndexCopyVector = vespalib::Array<EnumIndex>;
 
     EnumStoreBase::Index getEnumIndex(DocId docId) const { return _enumIndices[docId]; }
     EnumHandle getE(DocId doc) const { return _enumIndices[doc].ref(); }
diff --git a/searchlib/src/vespa/searchlib/attribute/singlenumericenumattribute.h b/searchlib/src/vespa/searchlib/attribute/singlenumericenumattribute.h
index 3793431f75b..125bf5587f3 100644
--- a/searchlib/src/vespa/searchlib/attribute/singlenumericenumattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/singlenumericenumattribute.h
@@ -30,7 +30,7 @@ protected:
     typedef typename B::BaseClass::generation_t    generation_t;
     typedef typename B::BaseClass::LoadedNumericValueT LoadedNumericValueT;
     typedef typename B::BaseClass::LoadedVector    LoadedVector;
-    typedef SequentialReadModifyWriteVector<LoadedNumericValueT, vespalib::DefaultAlloc> LoadedVectorR;
+    typedef SequentialReadModifyWriteVector<LoadedNumericValueT> LoadedVectorR;
 
     typedef typename SingleValueEnumAttribute<B>::EnumStore        EnumStore;
     typedef typename SingleValueEnumAttributeBase::EnumIndex       EnumIndex;
diff --git a/searchlib/src/vespa/searchlib/attribute/stringbase.h b/searchlib/src/vespa/searchlib/attribute/stringbase.h
index a70cc6ecfab..fde8e3847fc 100644
--- a/searchlib/src/vespa/searchlib/attribute/stringbase.h
+++ b/searchlib/src/vespa/searchlib/attribute/stringbase.h
@@ -19,7 +19,7 @@ class StringEntryType;
 class StringAttribute : public AttributeVector
 {
 public:
-    typedef vespalib::Array<uint32_t, vespalib::DefaultAlloc> OffsetVector;
+    typedef vespalib::Array<uint32_t> OffsetVector;
     typedef const char *                  LoadedValueType;
     typedef EnumStoreBase::Index          EnumIndex;
     typedef EnumStoreBase::IndexVector    EnumIndexVector;
diff --git a/searchlib/src/vespa/searchlib/attribute/tensorattribute.h b/searchlib/src/vespa/searchlib/attribute/tensorattribute.h
index 3c22d99882d..ec7f41bca18 100644
--- a/searchlib/src/vespa/searchlib/attribute/tensorattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/tensorattribute.h
@@ -29,7 +29,7 @@ private:
 
     void compactWorst();
 public:
-    using RefCopyVector = vespalib::Array<RefType, vespalib::DefaultAlloc>;
+    using RefCopyVector = vespalib::Array<RefType>;
     using Tensor = vespalib::tensor::Tensor;
     TensorAttribute(const vespalib::stringref &baseFileName, const Config &cfg);
     ~TensorAttribute();
diff --git a/searchlib/src/vespa/searchlib/btree/btreenodeallocator.h b/searchlib/src/vespa/searchlib/btree/btreenodeallocator.h
index 53e949bacbe..3029c287027 100644
--- a/searchlib/src/vespa/searchlib/btree/btreenodeallocator.h
+++ b/searchlib/src/vespa/searchlib/btree/btreenodeallocator.h
@@ -46,8 +46,8 @@ private:
 
     NodeStore _nodeStore;
 
-    typedef vespalib::Array<BTreeNode::Ref, vespalib::DefaultAlloc> RefVector;
-    typedef vespalib::Array<BTreeRootBaseType *, vespalib::DefaultAlloc> BTreeRootBaseTypeVector;
+    typedef vespalib::Array<BTreeNode::Ref> RefVector;
+    typedef vespalib::Array<BTreeRootBaseType *> BTreeRootBaseTypeVector;
     
     // Nodes that might not be frozen.
     RefVector _internalToFreeze;
diff --git a/searchlib/src/vespa/searchlib/btree/bufferstate.cpp b/searchlib/src/vespa/searchlib/btree/bufferstate.cpp
index 21f548187ee..d0dd62fec4b 100644
--- a/searchlib/src/vespa/searchlib/btree/bufferstate.cpp
+++ b/searchlib/src/vespa/searchlib/btree/bufferstate.cpp
@@ -125,9 +125,8 @@ BufferState::BufferState(void)
       _typeId(0),
       _clusterSize(0),
       _compacting(false),
-      _buffer()
+      _buffer(DefaultAlloc::create())
 {
-      _buffer.reset(new Alloc());
 }
 
 
@@ -163,14 +162,13 @@ BufferState::onActive(uint32_t bufferId, uint32_t typeId,
     assert(_freeListList == NULL || _freeListList->_head != this);
 
     size_t initialSizeNeeded = 0;
-    if (bufferId == 0)
+    if (bufferId == 0) {
         initialSizeNeeded = typeHandler->getClusterSize();
-    size_t allocClusters =
-        typeHandler->calcClustersToAlloc(initialSizeNeeded + sizeNeeded,
-                maxClusters);
+    }
+    size_t allocClusters = typeHandler->calcClustersToAlloc(initialSizeNeeded + sizeNeeded, maxClusters);
     size_t allocSize = allocClusters * typeHandler->getClusterSize();
     assert(allocSize >= initialSizeNeeded + sizeNeeded);
-    _buffer.reset(new Alloc(allocSize * typeHandler->elementSize()));
+    _buffer.create(allocSize * typeHandler->elementSize()).swap(_buffer);
     buffer = _buffer->get();
     typeHandler->onActive(&_usedElems);
     assert(buffer != NULL);
@@ -218,7 +216,7 @@ BufferState::onFree(void *&buffer)
     assert(_deadElems <= _usedElems);
     assert(_holdElems == _usedElems - _deadElems);
     _typeHandler->destroyElements(buffer, _usedElems);
-    Alloc().swap(*_buffer);
+    _buffer.create().swap(_buffer);
     _typeHandler->onFree(_usedElems);
     buffer = NULL;
     _usedElems = 0;
@@ -334,10 +332,9 @@ BufferState::fallbackResize(uint64_t newSize,
     size_t allocSize = allocClusters * _typeHandler->getClusterSize();
     assert(allocSize >= newSize);
     assert(allocSize > _allocElems);
-    Alloc::UP newBuffer(std::make_unique<Alloc>
-                        (allocSize * _typeHandler->elementSize()));
-    _typeHandler->fallbackCopy(newBuffer->get(), buffer, _usedElems);
-    holdBuffer.swap(*_buffer);
+    Alloc newBuffer = _buffer.create(allocSize * _typeHandler->elementSize());
+    _typeHandler->fallbackCopy(newBuffer.get(), buffer, _usedElems);
+    holdBuffer.swap(_buffer);
     std::atomic_thread_fence(std::memory_order_release);
     _buffer = std::move(newBuffer);
     buffer = _buffer->get();
diff --git a/searchlib/src/vespa/searchlib/btree/bufferstate.h b/searchlib/src/vespa/searchlib/btree/bufferstate.h
index 3c7a3557952..bbb8f77d5ef 100644
--- a/searchlib/src/vespa/searchlib/btree/bufferstate.h
+++ b/searchlib/src/vespa/searchlib/btree/bufferstate.h
@@ -13,14 +13,8 @@
 namespace search {
 namespace btree {
 
-
 class BufferTypeBase
 {
-private:
-    BufferTypeBase(const BufferTypeBase &rhs);
-
-    BufferTypeBase &
-    operator=(const BufferTypeBase &rhs);
 protected:
     uint32_t _clusterSize;	// Number of elements in an allocation unit
     uint32_t _minClusters;	// Minimum number of clusters to allocate
@@ -32,47 +26,21 @@ protected:
     const size_t *_lastUsedElems; // used elements in last active buffer
 
 public:
-    BufferTypeBase(uint32_t clusterSize,
-                   uint32_t minClusters,
-                   uint32_t maxClusters);
-
-    virtual
-    ~BufferTypeBase(void);
-
-    virtual void
-    destroyElements(void *buffer, size_t numElements) = 0;
-
-    virtual void
-    fallbackCopy(void *newBuffer,
-                 const void *oldBuffer,
-                 size_t numElements) = 0;
-
-    virtual void
-    cleanInitialElements(void *buffer) = 0;
-
-    virtual size_t
-    elementSize(void) const = 0;
-
-    virtual void
-    cleanHold(void *buffer, uint64_t offset, uint64_t len) = 0;
-
-    uint32_t
-    getClusterSize(void) const
-    {
-        return _clusterSize;
-    }
-
-    void
-    flushLastUsed(void);
-
-    void
-    onActive(const size_t *usedElems);
-
-    void
-    onHold(const size_t *usedElems);
-
-    virtual void
-    onFree(size_t usedElems);
+    
+    BufferTypeBase(const BufferTypeBase &rhs) = delete;
+    BufferTypeBase & operator=(const BufferTypeBase &rhs) = delete;
+    BufferTypeBase(uint32_t clusterSize, uint32_t minClusters, uint32_t maxClusters);
+    virtual ~BufferTypeBase();
+    virtual void destroyElements(void *buffer, size_t numElements) = 0;
+    virtual void fallbackCopy(void *newBuffer, const void *oldBuffer, size_t numElements) = 0;
+    virtual void cleanInitialElements(void *buffer) = 0;
+    virtual size_t elementSize() const = 0;
+    virtual void cleanHold(void *buffer, uint64_t offset, uint64_t len) = 0;
+    uint32_t getClusterSize() const { return _clusterSize; }
+    void flushLastUsed();
+    void onActive(const size_t *usedElems);
+    void onHold(const size_t *usedElems);
+    virtual void onFree(size_t usedElems);
 
     /**
      * Calculate number of clusters to allocate for new buffer.
@@ -82,9 +50,7 @@ public:
      *
      * @return number of clusters to allocate for new buffer
      */
-    virtual size_t
-    calcClustersToAlloc(size_t sizeNeeded,
-                        uint64_t clusterRefSize) const;
+    virtual size_t calcClustersToAlloc(size_t sizeNeeded, uint64_t clusterRefSize) const;
 
     uint32_t getActiveBuffers() const { return _activeBuffers; }
 };
@@ -93,41 +59,21 @@ public:
 template <typename EntryType>
 class BufferType : public  BufferTypeBase
 {
-private:
-    BufferType(const BufferType &rhs);
-
-    BufferType &
-    operator=(const BufferType &rhs);
 public:
     EntryType _emptyEntry;
 
-    BufferType(uint32_t clusterSize,
-               uint32_t minClusters,
-               uint32_t maxClusters)
+    BufferType(const BufferType &rhs) = delete;
+    BufferType & operator=(const BufferType &rhs) = delete;
+    BufferType(uint32_t clusterSize, uint32_t minClusters, uint32_t maxClusters)
         : BufferTypeBase(clusterSize, minClusters, maxClusters),
           _emptyEntry()
-    {
-    }
-
-    virtual void
-    destroyElements(void *buffer, size_t numElements);
+    { }
 
-    virtual void
-    fallbackCopy(void *newBuffer,
-                 const void *oldBuffer,
-                 size_t numElements);
-
-    virtual void
-    cleanInitialElements(void *buffer);
-
-    virtual void
-    cleanHold(void *buffer, uint64_t offset, uint64_t len);
-
-    virtual size_t
-    elementSize(void) const
-    {
-        return sizeof(EntryType);
-    }
+    void destroyElements(void *buffer, size_t numElements) override;
+    void fallbackCopy(void *newBuffer, const void *oldBuffer, size_t numElements) override;
+    void cleanInitialElements(void *buffer) override;
+    void cleanHold(void *buffer, uint64_t offset, uint64_t len) override;
+    size_t elementSize() const override { return sizeof(EntryType); }
 };
 
 
@@ -186,25 +132,20 @@ BufferType<EntryType>::cleanHold(void *buffer, uint64_t offset, uint64_t len)
 class BufferState
 {
 public:
-    typedef vespalib::DefaultAlloc Alloc;
+    typedef vespalib::alloc::Alloc Alloc;
 
     class FreeListList
     {
     public:
         BufferState *_head;
 
-        FreeListList(void)
-            : _head(NULL)
-        {
-        }
-
-        ~FreeListList(void);
+        FreeListList() : _head(NULL) { }
+        ~FreeListList();
     };
 
-    typedef vespalib::Array<EntryRef, vespalib::DefaultAlloc> FreeList;
+    typedef vespalib::Array<EntryRef> FreeList;
 
-    enum State
-    {
+    enum State {
         FREE,
         ACTIVE,
         HOLD
@@ -224,18 +165,17 @@ public:
     BufferState *_prevHasFree;
 
     BufferTypeBase *_typeHandler;
-    uint32_t _typeId;
-    uint32_t _clusterSize;
-    bool _compacting;
+    uint32_t        _typeId;
+    uint32_t        _clusterSize;
+    bool            _compacting;
 
     /*
      * TODO: Check if per-buffer free lists are useful, or if
      *compaction should always be used to free up whole buffers.
      */
 
-    BufferState(void);
-
-    ~BufferState(void);
+    BufferState();
+    ~BufferState();
 
     /**
      * Transition from FREE to ACTIVE state.
@@ -250,21 +190,17 @@ public:
      */
     void
     onActive(uint32_t bufferId, uint32_t typeId, BufferTypeBase *typeHandler,
-             size_t sizeNeeded,
-             size_t maxSize,
-             void *&buffer);
+             size_t sizeNeeded, size_t maxSize, void *&buffer);
 
     /**
      * Transition from ACTIVE to HOLD state.
      */
-    void
-    onHold(void);
+    void onHold();
 
     /**
      * Transition from HOLD to FREE state.
      */
-    void
-    onFree(void *&buffer);
+    void onFree(void *&buffer);
 
     /**
      * Set list of buffer states with nonempty free lists.
@@ -272,115 +208,57 @@ public:
      * @param freeListList	List of buffer states.  If NULL then free lists
      *				are disabled.
      */
-    void
-    setFreeListList(FreeListList *freeListList);
+    void setFreeListList(FreeListList *freeListList);
 
     /**
      * Add buffer state to list of buffer states with nonempty free lists.
      */
-    void
-    addToFreeListList(void);
+    void addToFreeListList();
 
     /**
      * Remove buffer state from list of buffer states with nonempty free lists.
      */
-    void
-    removeFromFreeListList(void);
+    void removeFromFreeListList();
 
     /**
      * Disable hold of elements, just mark then as dead without
      * cleanup.  Typically used when tearing down data structure in a
      * controlled manner.
      */
-    void
-    disableElemHoldList(void);
+    void disableElemHoldList();
 
     /**
      * Pop element from free list.
      */
-    EntryRef
-    popFreeList(void)
-    {
+    EntryRef popFreeList() {
         EntryRef ret = _freeList.back();
         _freeList.pop_back();
-        if (_freeList.empty())
+        if (_freeList.empty()) {
             removeFromFreeListList();
+        }
         _deadElems -= _clusterSize;
         return ret;
     }
 
-
-    size_t
-    size(void) const
-    {
-        return _usedElems;
-    }
-
-    size_t
-    capacity(void) const
-    {
-        return _allocElems;
-    }
-
-    size_t
-    remaining(void) const
-    {
-        return _allocElems - _usedElems;
-    }
-
-    void
-    pushed_back(uint64_t len)
-    {
-        _usedElems += len;
-    }
-
-    void
-    cleanHold(void *buffer, uint64_t offset, uint64_t len)
-    {
-        _typeHandler->cleanHold(buffer, offset, len);
-    }
-
-    void
-    dropBuffer(void *&buffer);
-
-    uint32_t
-    getTypeId(void) const
-    {
-        return _typeId;
-    }
-
-    uint32_t
-    getClusterSize(void) const
-    {
-        return _clusterSize;
-    }
-
+    size_t size() const { return _usedElems; }
+    size_t capacity() const { return _allocElems; }
+    size_t remaining() const { return _allocElems - _usedElems; }
+    void pushed_back(uint64_t len) { _usedElems += len; }
+    void cleanHold(void *buffer, uint64_t offset, uint64_t len) { _typeHandler->cleanHold(buffer, offset, len); }
+    void dropBuffer(void *&buffer);
+    uint32_t getTypeId() const { return _typeId; }
+    uint32_t getClusterSize() const { return _clusterSize; }
     uint64_t getDeadElems() const { return _deadElems; }
-
-    bool
-    getCompacting(void) const
-    {
-        return _compacting;
-    }
-
-    void
-    setCompacting(void)
-    {
-        _compacting = true;
-    }
-
-    void
-    fallbackResize(uint64_t newSize,
-                   size_t maxClusters,
-                   void *&buffer,
-                   Alloc &holdBuffer);
+    bool getCompacting() const { return _compacting; }
+    void setCompacting() { _compacting = true; }
+    void fallbackResize(uint64_t newSize, size_t maxClusters, void *&buffer, Alloc &holdBuffer);
 
     bool isActive(uint32_t typeId) const {
         return ((_state == ACTIVE) && (_typeId == typeId));
     }
 
 private:
-    Alloc::UP _buffer;
+    Alloc _buffer;
 };
 
 
diff --git a/searchlib/src/vespa/searchlib/btree/datastorebase.h b/searchlib/src/vespa/searchlib/btree/datastorebase.h
index 0c44b485d18..f948ada3d2f 100644
--- a/searchlib/src/vespa/searchlib/btree/datastorebase.h
+++ b/searchlib/src/vespa/searchlib/btree/datastorebase.h
@@ -57,7 +57,7 @@ protected:
         }
     };
 
-    typedef vespalib::Array<ElemHold1ListElem, vespalib::DefaultAlloc> ElemHold1List;
+    typedef vespalib::Array<ElemHold1ListElem> ElemHold1List;
     typedef std::deque<ElemHold2ListElem> ElemHold2List;
 
     class FallbackHold : public vespalib::GenerationHeldBase
diff --git a/searchlib/src/vespa/searchlib/common/allocatedbitvector.cpp b/searchlib/src/vespa/searchlib/common/allocatedbitvector.cpp
index 59d190b2b50..d6795f4b583 100644
--- a/searchlib/src/vespa/searchlib/common/allocatedbitvector.cpp
+++ b/searchlib/src/vespa/searchlib/common/allocatedbitvector.cpp
@@ -18,7 +18,7 @@ void AllocatedBitVector::alloc()
     uint32_t words = capacityWords();
     words += (-words & 15);	// Pad to 64 byte alignment
     const size_t sz(words * sizeof(Word));
-    Alloc(sz).swap(_alloc);
+    DefaultAlloc(sz).swap(_alloc);
     assert(_alloc.size()/sizeof(Word) >= words);
     // Clear padding
     memset(static_cast<char *>(_alloc.get()) + sizeBytes(), 0, sz - sizeBytes());
diff --git a/searchlib/src/vespa/searchlib/common/allocatedbitvector.h b/searchlib/src/vespa/searchlib/common/allocatedbitvector.h
index 8a52a07e29b..df1de516156 100644
--- a/searchlib/src/vespa/searchlib/common/allocatedbitvector.h
+++ b/searchlib/src/vespa/searchlib/common/allocatedbitvector.h
@@ -17,8 +17,7 @@ class BitVectorTest;
 class AllocatedBitVector : public BitVector
 {
 public:
-    typedef vespalib::AutoAlloc<0x800000, 0x1000> Alloc;
-
+    using Alloc = vespalib::alloc::Alloc;
     /**
      * Class constructor specifying size but not content.  New bitvector
      * is cleared.
diff --git a/searchlib/src/vespa/searchlib/common/rcuvector.h b/searchlib/src/vespa/searchlib/common/rcuvector.h
index 9c5954848c4..3c9274e3e94 100644
--- a/searchlib/src/vespa/searchlib/common/rcuvector.h
+++ b/searchlib/src/vespa/searchlib/common/rcuvector.h
@@ -44,7 +44,7 @@ class RcuVectorBase
                   "Value type must be trivially destructible");
 
 protected:
-    typedef vespalib::Array<T, vespalib::DefaultAlloc> Array;
+    typedef vespalib::Array<T> Array;
     typedef vespalib::GenerationHandler::generation_t generation_t;
     typedef vespalib::GenerationHolder GenerationHolder;
     Array              _data;
diff --git a/searchlib/src/vespa/searchlib/diskindex/docidmapper.h b/searchlib/src/vespa/searchlib/diskindex/docidmapper.h
index 43e1ea44b89..f150e8636a5 100644
--- a/searchlib/src/vespa/searchlib/diskindex/docidmapper.h
+++ b/searchlib/src/vespa/searchlib/diskindex/docidmapper.h
@@ -12,7 +12,7 @@ class BitVector;
 namespace diskindex
 {
 
-typedef vespalib::Array<uint8_t, vespalib::DefaultAlloc> SelectorArray;
+typedef vespalib::Array<uint8_t> SelectorArray;
 
 class DocIdMapping
 {
diff --git a/searchlib/src/vespa/searchlib/diskindex/indexbuilder.cpp b/searchlib/src/vespa/searchlib/diskindex/indexbuilder.cpp
index a88ce029814..0ec75cfbdf2 100644
--- a/searchlib/src/vespa/searchlib/diskindex/indexbuilder.cpp
+++ b/searchlib/src/vespa/searchlib/diskindex/indexbuilder.cpp
@@ -152,9 +152,9 @@ public:
         }
     };
 
-    typedef vespalib::Array<FHWordDocFieldFeatures, vespalib::DefaultAlloc>          FHWordDocFieldFeaturesVector;
-    typedef vespalib::Array<FHWordDocElementFeatures, vespalib::DefaultAlloc>        FHWordDocElementFeaturesVector;
-    typedef vespalib::Array<FHWordDocElementWordPosFeatures, vespalib::DefaultAlloc> FHWordDocElementWordPosFeaturesVector;
+    typedef vespalib::Array<FHWordDocFieldFeatures>          FHWordDocFieldFeaturesVector;
+    typedef vespalib::Array<FHWordDocElementFeatures>        FHWordDocElementFeaturesVector;
+    typedef vespalib::Array<FHWordDocElementWordPosFeatures> FHWordDocElementWordPosFeaturesVector;
 
     FHWordDocFieldFeaturesVector          _wdff;
     FHWordDocElementFeaturesVector        _wdfef;
diff --git a/searchlib/src/vespa/searchlib/diskindex/wordnummapper.h b/searchlib/src/vespa/searchlib/diskindex/wordnummapper.h
index a1a72757f22..d12e0211b94 100644
--- a/searchlib/src/vespa/searchlib/diskindex/wordnummapper.h
+++ b/searchlib/src/vespa/searchlib/diskindex/wordnummapper.h
@@ -14,7 +14,7 @@ class WordNumMapper;
 
 class WordNumMapping
 {
-    typedef vespalib::Array<uint64_t, vespalib::DefaultAlloc> Array;
+    typedef vespalib::Array<uint64_t> Array;
 
     static uint64_t
     noWordNumHigh(void)
diff --git a/searchlib/src/vespa/searchlib/docstore/documentstore.h b/searchlib/src/vespa/searchlib/docstore/documentstore.h
index d44c94fe7f8..7ca3b98d525 100644
--- a/searchlib/src/vespa/searchlib/docstore/documentstore.h
+++ b/searchlib/src/vespa/searchlib/docstore/documentstore.h
@@ -173,7 +173,7 @@ private:
             _compressedSize(rhs._compressedSize),
             _uncompressedSize(rhs._uncompressedSize),
             _compression(rhs._compression),
-            _buf(rhs.size())
+            _buf(vespalib::DefaultAlloc::create(rhs.size()))
         {
             memcpy(get(), rhs.get(), size());
         }
@@ -213,7 +213,7 @@ private:
         size_t _compressedSize;
         size_t _uncompressedSize;
         document::CompressionConfig::Type _compression;
-        vespalib::DefaultAlloc _buf;
+        vespalib::alloc::Alloc _buf;
     };
     class BackingStore {
     public:
diff --git a/searchlib/src/vespa/searchlib/docstore/filechunk.cpp b/searchlib/src/vespa/searchlib/docstore/filechunk.cpp
index 36ee94f9f8f..f76d12ed7aa 100644
--- a/searchlib/src/vespa/searchlib/docstore/filechunk.cpp
+++ b/searchlib/src/vespa/searchlib/docstore/filechunk.cpp
@@ -293,7 +293,7 @@ public:
     }
 };
 
-typedef vespalib::Array<TmpChunkMeta, vespalib::DefaultAlloc> TmpChunkMetaV;
+typedef vespalib::Array<TmpChunkMeta> TmpChunkMetaV;
 
 namespace {
 
diff --git a/searchlib/src/vespa/searchlib/docstore/filechunk.h b/searchlib/src/vespa/searchlib/docstore/filechunk.h
index 5c2006a7083..27cccc59290 100644
--- a/searchlib/src/vespa/searchlib/docstore/filechunk.h
+++ b/searchlib/src/vespa/searchlib/docstore/filechunk.h
@@ -345,7 +345,7 @@ protected:
     ssize_t read(uint32_t lid, SubChunkId chunkId, const ChunkInfo & chunkInfo, vespalib::DataBuffer & buffer) const;
     void read(LidInfoWithLidV::const_iterator begin, size_t count, ChunkInfo ci, IBufferVisitor & visitor) const;
 
-    typedef vespalib::Array<ChunkInfo, vespalib::DefaultAlloc> ChunkInfoVector;
+    typedef vespalib::Array<ChunkInfo> ChunkInfoVector;
     const IBucketizer * _bucketizer;
     size_t              _addedBytes;
     TuneFileSummary     _tune;
diff --git a/searchlib/src/vespa/searchlib/docstore/storebybucket.h b/searchlib/src/vespa/searchlib/docstore/storebybucket.h
index a7144596d0b..b6a25ef1dff 100644
--- a/searchlib/src/vespa/searchlib/docstore/storebybucket.h
+++ b/searchlib/src/vespa/searchlib/docstore/storebybucket.h
@@ -60,7 +60,7 @@ private:
         uint32_t _chunkId;
         uint32_t _lid;
     };
-    using IndexVector = vespalib::Array<Index, vespalib::DefaultAlloc>;
+    using IndexVector = vespalib::Array<Index>;
     uint64_t                                     _chunkSerial;
     Chunk::UP                                    _current;
     std::map<uint64_t, IndexVector>              _where;
diff --git a/searchlib/src/vespa/searchlib/docstore/visitcache.cpp b/searchlib/src/vespa/searchlib/docstore/visitcache.cpp
index 43a8c1b33aa..79d7fd4e26d 100644
--- a/searchlib/src/vespa/searchlib/docstore/visitcache.cpp
+++ b/searchlib/src/vespa/searchlib/docstore/visitcache.cpp
@@ -35,7 +35,7 @@ size_t getBufferSize(const BlobSet::Positions & p) {
 
 }
 
-BlobSet::BlobSet(const Positions & positions, vespalib::DefaultAlloc && buffer) :
+BlobSet::BlobSet(const Positions & positions, vespalib::alloc::Alloc && buffer) :
     _positions(positions),
     _buffer(std::move(buffer), getBufferSize(_positions))
 {
diff --git a/searchlib/src/vespa/searchlib/docstore/visitcache.h b/searchlib/src/vespa/searchlib/docstore/visitcache.h
index fb1b61310f8..518280bcc09 100644
--- a/searchlib/src/vespa/searchlib/docstore/visitcache.h
+++ b/searchlib/src/vespa/searchlib/docstore/visitcache.h
@@ -47,7 +47,7 @@ public:
 
     using Positions = std::vector<LidPosition>;
     BlobSet();
-    BlobSet(const Positions & positions, vespalib::DefaultAlloc && buffer);
+    BlobSet(const Positions & positions, vespalib::alloc::Alloc && buffer);
     void append(uint32_t lid, vespalib::ConstBufferRef blob);
     void remove(uint32_t lid);
     const Positions & getPositions() const { return _positions; }
diff --git a/searchlib/src/vespa/searchlib/engine/searchreply.h b/searchlib/src/vespa/searchlib/engine/searchreply.h
index 692806114ee..0e7ab43e66d 100644
--- a/searchlib/src/vespa/searchlib/engine/searchreply.h
+++ b/searchlib/src/vespa/searchlib/engine/searchreply.h
@@ -56,7 +56,7 @@ public:
     search::HitRank       maxRank;
     std::vector<uint32_t> sortIndex;
     std::vector<char>     sortData;
-    vespalib::Array<char, vespalib::DefaultAlloc> groupResult;
+    vespalib::Array<char> groupResult;
     bool                  useCoverage;
     Coverage              coverage;
     bool                  useWideHits;
diff --git a/searchlib/src/vespa/searchlib/grouping/sketch.h b/searchlib/src/vespa/searchlib/grouping/sketch.h
index 0a475a9e805..e336955f337 100644
--- a/searchlib/src/vespa/searchlib/grouping/sketch.h
+++ b/searchlib/src/vespa/searchlib/grouping/sketch.h
@@ -226,19 +226,16 @@ decompress_buckets_from(char *buffer, uint32_t size) {
         memcpy(bucket, buffer, BUCKET_COUNT);
     } else {
         vespalib::ConstBufferRef compressed(buffer, size);
-        vespalib::DataBuffer uncompressed(reinterpret_cast<char *>(&bucket[0]),
-                                          BUCKET_COUNT);
-        document::decompress(document::CompressionConfig::LZ4, BUCKET_COUNT,
-                             compressed, uncompressed, false);
+        vespalib::DataBuffer uncompressed(reinterpret_cast<char *>(&bucket[0]), BUCKET_COUNT);
+        document::decompress(document::CompressionConfig::LZ4, BUCKET_COUNT, compressed, uncompressed, false);
     }
 }
 template <int BucketBits, typename HashT>
 void NormalSketch<BucketBits, HashT>::
 serialize(vespalib::Serializer &os) const {
-    vespalib::DefaultAlloc backing(LZ4_compressBound(BUCKET_COUNT));
+    vespalib::alloc::Alloc backing(vespalib::DefaultAlloc::create(LZ4_compressBound(BUCKET_COUNT)));
     char * compress_array(static_cast<char *>(backing.get()));
-    uint32_t size =
-        compress_buckets_into(compress_array, backing.size());
+    uint32_t size = compress_buckets_into(compress_array, backing.size());
     os << BUCKET_COUNT << size;
     for (size_t i = 0; i < size; ++i) {
         os << static_cast<uint8_t>(compress_array[i]);
diff --git a/searchlib/src/vespa/searchlib/memoryindex/fieldinverter.h b/searchlib/src/vespa/searchlib/memoryindex/fieldinverter.h
index 1f72c8e62b4..47d1031d546 100644
--- a/searchlib/src/vespa/searchlib/memoryindex/fieldinverter.h
+++ b/searchlib/src/vespa/searchlib/memoryindex/fieldinverter.h
@@ -98,7 +98,7 @@ private:
     FieldInverter &operator=(const FieldInverter &) = delete;
     FieldInverter &operator=(const FieldInverter &&) = delete;
 
-    typedef vespalib::Array<char, vespalib::DefaultAlloc> WordBuffer;
+    typedef vespalib::Array<char> WordBuffer;
 
     class ElemInfo
     {
diff --git a/searchlib/src/vespa/searchlib/memoryindex/memoryfieldindex.cpp b/searchlib/src/vespa/searchlib/memoryindex/memoryfieldindex.cpp
index 88b718e1860..ba0c8e95efa 100644
--- a/searchlib/src/vespa/searchlib/memoryindex/memoryfieldindex.cpp
+++ b/searchlib/src/vespa/searchlib/memoryindex/memoryfieldindex.cpp
@@ -173,7 +173,7 @@ MemoryFieldIndex::dump(search::index::IndexBuilder & indexBuilder)
     vespalib::stringref word;
     FeatureStore::DecodeContextCooked decoder(NULL);
     DocIdAndFeatures features;
-    vespalib::Array<uint32_t, vespalib::DefaultAlloc> wordMap(_numUniqueWords + 1, 0);
+    vespalib::Array<uint32_t> wordMap(_numUniqueWords + 1, 0);
     _featureStore.setupForField(_fieldId, decoder);
     for (DictionaryTree::Iterator itr = _dict.begin(); itr.valid(); ++itr) {
         const WordKey & wk = itr.getKey();
diff --git a/searchlib/src/vespa/searchlib/predicate/document_features_store.h b/searchlib/src/vespa/searchlib/predicate/document_features_store.h
index 314e7347f27..8d910f8506c 100644
--- a/searchlib/src/vespa/searchlib/predicate/document_features_store.h
+++ b/searchlib/src/vespa/searchlib/predicate/document_features_store.h
@@ -72,7 +72,7 @@ public:
     typedef std::unordered_set<uint64_t> FeatureSet;
 
     DocumentFeaturesStore(uint32_t arity);
-    DocumentFeaturesStore(vespalib::MMapDataBuffer &buffer);
+    DocumentFeaturesStore(vespalib::DataBuffer &buffer);
     ~DocumentFeaturesStore();
 
     void insert(uint64_t featureId, uint32_t docId);
@@ -81,7 +81,7 @@ public:
     void remove(uint32_t docId);
     search::MemoryUsage getMemoryUsage() const;
 
-    void serialize(vespalib::MMapDataBuffer &buffer) const;
+    void serialize(vespalib::DataBuffer &buffer) const;
 };
 
 }  // namespace predicate
diff --git a/searchlib/src/vespa/searchlib/predicate/predicate_index.cpp b/searchlib/src/vespa/searchlib/predicate/predicate_index.cpp
index 81533c36951..6e597d55f3b 100644
--- a/searchlib/src/vespa/searchlib/predicate/predicate_index.cpp
+++ b/searchlib/src/vespa/searchlib/predicate/predicate_index.cpp
@@ -12,7 +12,7 @@
 LOG_SETUP(".predicate_index");
 
 using search::btree::EntryRef;
-using vespalib::MMapDataBuffer;
+using vespalib::DataBuffer;
 using std::vector;
 
 namespace search {
@@ -63,7 +63,7 @@ class IntervalSerializer : public PostingSerializer<EntryRef> {
 public:
     IntervalSerializer(const PredicateIntervalStore &store) : _store(store) {}
     virtual void serialize(const EntryRef &ref,
-                           vespalib::MMapDataBuffer &buffer) const {
+                           vespalib::DataBuffer &buffer) const {
         uint32_t size;
         IntervalT single_buf;
         const IntervalT *interval = _store.get(ref, size, &single_buf);
@@ -81,7 +81,7 @@ class IntervalDeserializer : public PostingDeserializer<EntryRef> {
     PredicateIntervalStore &_store;
 public:
     IntervalDeserializer(PredicateIntervalStore &store) : _store(store) {}
-    virtual EntryRef deserialize(vespalib::MMapDataBuffer &buffer) {
+    virtual EntryRef deserialize(vespalib::DataBuffer &buffer) {
         std::vector<IntervalT> intervals;
         size_t size = buffer.readInt16();
         for (uint32_t i = 0; i < size; ++i) {
@@ -95,7 +95,7 @@ public:
 
 PredicateIndex::PredicateIndex(GenerationHandler &generation_handler, GenerationHolder &genHolder,
                                const DocIdLimitProvider &limit_provider,
-                               const SimpleIndexConfig &simple_index_config, MMapDataBuffer &buffer,
+                               const SimpleIndexConfig &simple_index_config, DataBuffer &buffer,
                                SimpleIndexDeserializeObserver<> & observer, uint32_t version)
     : _arity(0),
       _generation_handler(generation_handler),
@@ -125,7 +125,7 @@ PredicateIndex::PredicateIndex(GenerationHandler &generation_handler, Generation
     commit();
 }
 
-void PredicateIndex::serialize(MMapDataBuffer &buffer) const {
+void PredicateIndex::serialize(DataBuffer &buffer) const {
     _features_store.serialize(buffer);
     buffer.writeInt16(_arity);
     buffer.writeInt32(_zero_constraint_docs.size());
diff --git a/searchlib/src/vespa/searchlib/predicate/predicate_index.h b/searchlib/src/vespa/searchlib/predicate/predicate_index.h
index d2e5c1f268e..3673f4378ad 100644
--- a/searchlib/src/vespa/searchlib/predicate/predicate_index.h
+++ b/searchlib/src/vespa/searchlib/predicate/predicate_index.h
@@ -82,10 +82,10 @@ public:
     // The observer can be used to gain some insight into what has been added to the index..
     PredicateIndex(GenerationHandler &generation_handler, GenerationHolder &genHolder,
                    const DocIdLimitProvider &limit_provider,
-                   const SimpleIndexConfig &simple_index_config, vespalib::MMapDataBuffer &buffer,
+                   const SimpleIndexConfig &simple_index_config, vespalib::DataBuffer &buffer,
                    SimpleIndexDeserializeObserver<> & observer, uint32_t version);
 
-    void serialize(vespalib::MMapDataBuffer &buffer) const;
+    void serialize(vespalib::DataBuffer &buffer) const;
     void onDeserializationCompleted();
 
     void indexEmptyDocument(uint32_t doc_id);
diff --git a/searchlib/src/vespa/searchlib/predicate/predicate_interval.h b/searchlib/src/vespa/searchlib/predicate/predicate_interval.h
index fede659582a..3a288c4aedb 100644
--- a/searchlib/src/vespa/searchlib/predicate/predicate_interval.h
+++ b/searchlib/src/vespa/searchlib/predicate/predicate_interval.h
@@ -16,10 +16,10 @@ struct Interval {
     Interval() : interval(0) {}
     Interval(uint32_t interval_) : interval(interval_) {}
 
-    void serialize(vespalib::MMapDataBuffer &buffer) const {
+    void serialize(vespalib::DataBuffer &buffer) const {
         buffer.writeInt32(interval);
     }
-    static Interval deserialize(vespalib::MMapDataBuffer &buffer) {
+    static Interval deserialize(vespalib::DataBuffer &buffer) {
         return Interval{buffer.readInt32()};
     }
     bool operator==(const Interval &other) const {
@@ -42,11 +42,11 @@ struct IntervalWithBounds {
     IntervalWithBounds() : interval(0), bounds(0) {}
     IntervalWithBounds(uint32_t interval_, uint32_t bounds_) : interval(interval_), bounds(bounds_) {}
 
-    void serialize(vespalib::MMapDataBuffer &buffer) const {
+    void serialize(vespalib::DataBuffer &buffer) const {
         buffer.writeInt32(interval);
         buffer.writeInt32(bounds);
     }
-    static IntervalWithBounds deserialize(vespalib::MMapDataBuffer &buffer) {
+    static IntervalWithBounds deserialize(vespalib::DataBuffer &buffer) {
         uint32_t interval = buffer.readInt32();
         uint32_t bounds = buffer.readInt32();
         return IntervalWithBounds{interval, bounds};
diff --git a/searchlib/src/vespa/searchlib/predicate/simple_index.h b/searchlib/src/vespa/searchlib/predicate/simple_index.h
index be6fc098682..b61f31f79a0 100644
--- a/searchlib/src/vespa/searchlib/predicate/simple_index.h
+++ b/searchlib/src/vespa/searchlib/predicate/simple_index.h
@@ -31,13 +31,13 @@ template <typename Posting>
 struct PostingSerializer {
     virtual ~PostingSerializer() {}
     virtual void serialize(const Posting &posting,
-                           vespalib::MMapDataBuffer &buffer) const = 0;
+                           vespalib::DataBuffer &buffer) const = 0;
 };
 
 template <typename Posting>
 struct PostingDeserializer {
     virtual ~PostingDeserializer() {}
-    virtual Posting deserialize(vespalib::MMapDataBuffer &buffer) = 0;
+    virtual Posting deserialize(vespalib::DataBuffer &buffer) = 0;
 };
 
 struct DocIdLimitProvider {
@@ -195,9 +195,9 @@ public:
         : _generation_holder(generation_holder), _config(config), _limit_provider(provider) {}
     ~SimpleIndex();
 
-    void serialize(vespalib::MMapDataBuffer &buffer,
+    void serialize(vespalib::DataBuffer &buffer,
                    const PostingSerializer<Posting> &serializer) const;
-    void deserialize(vespalib::MMapDataBuffer &buffer,
+    void deserialize(vespalib::DataBuffer &buffer,
                      PostingDeserializer<Posting> &deserializer,
                      SimpleIndexDeserializeObserver<Key, DocId> &observer, uint32_t version);
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/predicate_blueprint.cpp b/searchlib/src/vespa/searchlib/queryeval/predicate_blueprint.cpp
index 70903788992..1610267c255 100644
--- a/searchlib/src/vespa/searchlib/queryeval/predicate_blueprint.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/predicate_blueprint.cpp
@@ -250,7 +250,7 @@ void PredicateBlueprint::fetchPostings(bool) {
     }
 
     PredicateAttribute::MinFeatureHandle mfh = predicate_attribute().getMinFeatureVector();
-    vespalib::DefaultAlloc kv(mfh.second);
+    vespalib::alloc::Alloc kv(vespalib::DefaultAlloc::create(mfh.second));
     _kVBacking.swap(kv);
     _kV = BitVectorCache::CountVector(static_cast<uint8_t *>(_kVBacking.get()), mfh.second);
     _index.computeCountVector(_cachedFeatures, _kV);
diff --git a/searchlib/src/vespa/searchlib/queryeval/predicate_blueprint.h b/searchlib/src/vespa/searchlib/queryeval/predicate_blueprint.h
index aeab9d4175f..616460f9e55 100644
--- a/searchlib/src/vespa/searchlib/queryeval/predicate_blueprint.h
+++ b/searchlib/src/vespa/searchlib/queryeval/predicate_blueprint.h
@@ -72,7 +72,7 @@ private:
 
     const PredicateAttribute & _attribute;
     const predicate::PredicateIndex &_index;
-    vespalib::DefaultAlloc _kVBacking;
+    vespalib::alloc::Alloc _kVBacking;
     BitVectorCache::CountVector _kV;
     BitVectorCache::KeySet _cachedFeatures;
 
diff --git a/searchlib/src/vespa/searchlib/util/fileutil.h b/searchlib/src/vespa/searchlib/util/fileutil.h
index 69d2cc557a6..b61c4e9d0ac 100644
--- a/searchlib/src/vespa/searchlib/util/fileutil.h
+++ b/searchlib/src/vespa/searchlib/util/fileutil.h
@@ -295,11 +295,11 @@ public:
     virtual void rewind() = 0;
 };
 
-template <typename T, typename A=vespalib::HeapAlloc>
-class SequentialReadModifyWriteVector : public SequentialReadModifyWriteInterface<T>, public vespalib::Array<T, A>
+template <typename T>
+class SequentialReadModifyWriteVector : public SequentialReadModifyWriteInterface<T>, public vespalib::Array<T>
 {
 private:
-    typedef vespalib::Array<T, A> Vector;
+    typedef vespalib::Array<T> Vector;
 public:
     SequentialReadModifyWriteVector() : Vector(), _rp(0), _wp(0) { }
     SequentialReadModifyWriteVector(size_t sz) : Vector(sz), _rp(0), _wp(0) { }
diff --git a/staging_vespalib/src/tests/array/allocinarray_benchmark.cpp b/staging_vespalib/src/tests/array/allocinarray_benchmark.cpp
index 9f365ff937c..426cb7ee3b8 100644
--- a/staging_vespalib/src/tests/array/allocinarray_benchmark.cpp
+++ b/staging_vespalib/src/tests/array/allocinarray_benchmark.cpp
@@ -60,7 +60,7 @@ private:
 
 typedef TreeNode<long> N;
 typedef RefTreeNode<long> R;
-typedef AllocInArray<R, vespalib::Array<R, MMapAlloc> > Store;
+typedef AllocInArray<R, vespalib::Array<R> > Store;
 
 void populate(Store & store, uint32_t parent, size_t depth)
 {
diff --git a/staging_vespalib/src/tests/array/allocinarray_test.cpp b/staging_vespalib/src/tests/array/allocinarray_test.cpp
index 3a40a71f288..de6e5792b35 100644
--- a/staging_vespalib/src/tests/array/allocinarray_test.cpp
+++ b/staging_vespalib/src/tests/array/allocinarray_test.cpp
@@ -26,7 +26,7 @@ Test::Main()
     TEST_INIT("allocinarray_test");
 
     testAllocInArray<int64_t, vespalib::Array<int64_t> >();
-    testAllocInArray<int64_t, vespalib::Array<int64_t, vespalib::DefaultAlloc> >();
+    testAllocInArray<int64_t, vespalib::Array<int64_t> >();
     testAllocInArray<int64_t, std::vector<int64_t> >();
     testAllocInArray<int64_t, std::deque<int64_t> >();
 
diff --git a/staging_vespalib/src/vespa/vespalib/data/databuffer.cpp b/staging_vespalib/src/vespa/vespalib/data/databuffer.cpp
index 26a7eac824f..e046415e8e8 100644
--- a/staging_vespalib/src/vespa/vespalib/data/databuffer.cpp
+++ b/staging_vespalib/src/vespa/vespalib/data/databuffer.cpp
@@ -12,21 +12,20 @@ size_t padbefore(size_t alignment, const char *buf) {
 }
 }
 
-template <typename T>
-DataBufferT<T>::DataBufferT(size_t len, size_t alignment)
+DataBuffer::DataBuffer(size_t len, size_t alignment, const Alloc & initial)
     : _alignment(alignment),
       _externalBuf(NULL),
       _bufstart(NULL),
       _bufend(NULL),
       _datapt(NULL),
       _freept(NULL),
-      _buffer()
+      _buffer(initial.create(0))
 {
     assert(_alignment > 0);
     if (len > 0) {
         // avoid very small buffers for performance reasons:
         size_t bufsize = std::max(256ul, roundUp2inN(len + (_alignment - 1)));
-        T newBuf(bufsize);
+        Alloc newBuf(initial.create(bufsize));
         _bufstart = static_cast<char *>(newBuf.get());
         _buffer.swap(newBuf);
 
@@ -38,18 +37,16 @@ DataBufferT<T>::DataBufferT(size_t len, size_t alignment)
 }
 
 
-template <typename T>
 void
-DataBufferT<T>::moveFreeToData(size_t len)
+DataBuffer::moveFreeToData(size_t len)
 {
     assert(getFreeLen() >= len);
     _freept += len;
 }
 
 
-template <typename T>
 void
-DataBufferT<T>::moveDeadToData(size_t len)
+DataBuffer::moveDeadToData(size_t len)
 {
     assert(getDeadLen() >= len);
     _datapt -= len;
@@ -59,18 +56,16 @@ DataBufferT<T>::moveDeadToData(size_t len)
 }
 
 
-template <typename T>
 void
-DataBufferT<T>::moveDataToFree(size_t len)
+DataBuffer::moveDataToFree(size_t len)
 {
     assert(getDataLen() >= len);
     _freept -= len;
 }
 
 
-template <typename T>
 bool
-DataBufferT<T>::shrink(size_t newsize)
+DataBuffer::shrink(size_t newsize)
 {
     if (getBufSize() <= newsize || getDataLen() > newsize) {
         return false;
@@ -78,7 +73,7 @@ DataBufferT<T>::shrink(size_t newsize)
     char *newbuf = NULL;
     char *newdata = NULL;
     newsize += (_alignment - 1);
-    T newBuf(newsize);
+    Alloc newBuf(_buffer.create(newsize));
     if (newsize != 0) {
         newbuf = static_cast<char *>(newBuf.get());
         newdata = newbuf + padbefore(_alignment, newbuf);
@@ -93,9 +88,8 @@ DataBufferT<T>::shrink(size_t newsize)
 }
 
 
-template <typename T>
 void
-DataBufferT<T>::pack(size_t needbytes)
+DataBuffer::pack(size_t needbytes)
 {
     needbytes += (_alignment - 1);
     size_t dataLen = getDataLen();
@@ -104,7 +98,7 @@ DataBufferT<T>::pack(size_t needbytes)
         (getDeadLen() + getFreeLen()) * 4 < dataLen)
     {
         size_t bufsize = std::max(256ul, roundUp2inN(needbytes+dataLen));
-        T newBuf(bufsize);
+        Alloc newBuf(_buffer.create(bufsize));
         char *newbuf = static_cast<char *>(newBuf.get());
         char *newdata = newbuf + padbefore(_alignment, newbuf);
         memcpy(newdata, _datapt, dataLen);
@@ -122,9 +116,8 @@ DataBufferT<T>::pack(size_t needbytes)
 }
 
 
-template <typename T>
 bool
-DataBufferT<T>::equals(DataBufferT *other)
+DataBuffer::equals(DataBuffer *other)
 {
     if (getDataLen() != other->getDataLen())
         return false;
@@ -132,9 +125,8 @@ DataBufferT<T>::equals(DataBufferT *other)
 }
 
 
-template <typename T>
 void
-DataBufferT<T>::hexDump()
+DataBuffer::hexDump()
 {
     char *pt = _datapt;
     printf("*** DataBuffer HexDump BEGIN ***\n");
@@ -150,9 +142,8 @@ DataBufferT<T>::hexDump()
 }
 
 
-template <typename T>
 void
-DataBufferT<T>::swap(DataBufferT &other)
+DataBuffer::swap(DataBuffer &other)
 {
     _buffer.swap(other._buffer);
     std::swap(_alignment, other._alignment);
@@ -163,9 +154,8 @@ DataBufferT<T>::swap(DataBufferT &other)
     std::swap(_freept, other._freept);
 }
 
-template <typename T>
-T
-DataBufferT<T>::stealBuffer()
+vespalib::alloc::Alloc
+DataBuffer::stealBuffer()
 {
     assert( ! referencesExternalData() );
     _externalBuf = nullptr;
@@ -176,15 +166,9 @@ DataBufferT<T>::stealBuffer()
     return std::move(_buffer);
 }
 
-template <typename T>
 bool
-DataBufferT<T>::referencesExternalData() const {
+DataBuffer::referencesExternalData() const {
     return (_externalBuf == _bufstart) && (getBufSize() > 0);
 }
 
-template class DataBufferT<HeapAlloc>;
-template class DataBufferT<MMapAlloc>;
-template class DataBufferT<DefaultAlloc>;
-
-
 } // namespace vespalib
diff --git a/staging_vespalib/src/vespa/vespalib/data/databuffer.h b/staging_vespalib/src/vespa/vespalib/data/databuffer.h
index 7db17808eae..76a604732f5 100644
--- a/staging_vespalib/src/vespa/vespalib/data/databuffer.h
+++ b/staging_vespalib/src/vespa/vespalib/data/databuffer.h
@@ -30,23 +30,23 @@ namespace vespalib {
  * the data will be relocated within the buffer and/or a bigger buffer
  * will be allocated.
  **/
-template <typename T>
-class DataBufferT
+class DataBuffer
 {
 private:
+    using Alloc = vespalib::alloc::Alloc;
     size_t         _alignment;
     char          *_externalBuf;
     char          *_bufstart;
     char          *_bufend;
     char          *_datapt;
     char          *_freept;
-    T              _buffer;
+    Alloc          _buffer;
 
-    DataBufferT(const DataBufferT &);
-    DataBufferT &operator=(const DataBufferT &);
+    DataBuffer(const DataBuffer &);
+    DataBuffer &operator=(const DataBuffer &);
 
 public:
-    typedef std::unique_ptr<DataBufferT<T>> UP;
+    typedef std::unique_ptr<DataBuffer> UP;
 
     /**
      * Construct a databuffer.
@@ -54,7 +54,7 @@ public:
      * @param len the initial size of the buffer.
      * @param alignment required memory alignment for data start
      **/
-    DataBufferT(size_t len = 1024, size_t alignment = 1);
+    DataBuffer(size_t len = 1024, size_t alignment = 1, const Alloc & initial = vespalib::DefaultAlloc::create(0));
 
     /**
      * Construct a databuffer using externally allocated memory. Note
@@ -64,22 +64,24 @@ public:
      * @param buf pointer to preallocated memory
      * @param len length of preallocated memory
      **/
-    DataBufferT(char *buf, size_t len) :
+    DataBuffer(char *buf, size_t len) :
         _alignment(1),
         _externalBuf(buf),
         _bufstart(buf),
         _bufend(buf + len),
         _datapt(_bufstart),
-        _freept(_bufstart)
+        _freept(_bufstart),
+        _buffer(vespalib::DefaultAlloc::create(0))
     { }
 
-    DataBufferT(const char *buf, size_t len) :
+    DataBuffer(const char *buf, size_t len) :
         _alignment(1),
         _externalBuf(const_cast<char *>(buf)),
         _bufstart(_externalBuf),
         _bufend(_bufstart + len),
         _datapt(_bufstart),
-        _freept(_bufend)
+        _freept(_bufend),
+        _buffer(vespalib::DefaultAlloc::create(0))
     { }
 
     /**
@@ -570,7 +572,7 @@ public:
      * @return true(equal)/false(not equal)
      * @param other the other buffer.
      **/
-    bool equals(DataBufferT *other);
+    bool equals(DataBuffer *other);
 
     /**
      * Print a human-readable representation of this buffer to
@@ -601,13 +603,10 @@ public:
      *
      * @param other the other buffer.
      **/
-    void swap(DataBufferT &other);
+    void swap(DataBuffer &other);
 
-    T stealBuffer();
+    Alloc stealBuffer();
 };
 
-typedef DataBufferT<DefaultAlloc> DataBuffer;
-typedef DataBufferT<MMapAlloc> MMapDataBuffer;
-
 } // namespace vespalib
 
diff --git a/staging_vespalib/src/vespa/vespalib/util/allocinarray.h b/staging_vespalib/src/vespa/vespalib/util/allocinarray.h
index a6a89c4d41a..755d1885eee 100644
--- a/staging_vespalib/src/vespa/vespalib/util/allocinarray.h
+++ b/staging_vespalib/src/vespa/vespalib/util/allocinarray.h
@@ -16,7 +16,7 @@ namespace vespalib {
  *   - when the AllocInArray goes out of scope.
  *   - on an explicit clear.
 **/
-template <typename T, typename V=vespalib::Array<T, HeapAlloc> >
+template <typename T, typename V=vespalib::Array<T> >
 class AllocInArray {
 public:
     typedef uint32_t Index;
diff --git a/staging_vespalib/src/vespa/vespalib/util/growablebytebuffer.cpp b/staging_vespalib/src/vespa/vespalib/util/growablebytebuffer.cpp
index 96e74ecf007..b17accddc5d 100644
--- a/staging_vespalib/src/vespa/vespalib/util/growablebytebuffer.cpp
+++ b/staging_vespalib/src/vespa/vespalib/util/growablebytebuffer.cpp
@@ -5,7 +5,7 @@
 using namespace vespalib;
 
 GrowableByteBuffer::GrowableByteBuffer(uint32_t initialLen) :
-    _buffer(initialLen),
+    _buffer(DefaultAlloc::create(initialLen)),
     _position(0)
 {
 }
@@ -16,7 +16,7 @@ GrowableByteBuffer::allocate(uint32_t len)
     size_t need(_position + len);
     if (need > _buffer.size()) {
         uint32_t newSize = vespalib::roundUp2inN(need);
-        DefaultAlloc newBuf(newSize);
+        Alloc newBuf(DefaultAlloc::create(newSize));
         memcpy(newBuf.get(), _buffer.get(), _position);
         _buffer.swap(newBuf);
     }
diff --git a/staging_vespalib/src/vespa/vespalib/util/growablebytebuffer.h b/staging_vespalib/src/vespa/vespalib/util/growablebytebuffer.h
index 61baa250e40..fd65f0134bc 100644
--- a/staging_vespalib/src/vespa/vespalib/util/growablebytebuffer.h
+++ b/staging_vespalib/src/vespa/vespalib/util/growablebytebuffer.h
@@ -85,8 +85,8 @@ public:
 
 private:
     void putReverse(const char* buffer, uint32_t length);
-
-    DefaultAlloc _buffer;
+    using Alloc = vespalib::alloc::Alloc;
+    Alloc _buffer;
 
     uint32_t _position;
     double   _growFactor;
diff --git a/storage/src/vespa/storage/bucketdb/judymultimap.h b/storage/src/vespa/storage/bucketdb/judymultimap.h
index 52f4793aa7c..c6f0194c7bd 100644
--- a/storage/src/vespa/storage/bucketdb/judymultimap.h
+++ b/storage/src/vespa/storage/bucketdb/judymultimap.h
@@ -151,10 +151,10 @@ public:
 
 private:
     JudyArray _judyArray;
-    typedef vespalib::Array<Type0, vespalib::DefaultAlloc> Type0Vector;
-    typedef vespalib::Array<Type1, vespalib::DefaultAlloc> Type1Vector;
-    typedef vespalib::Array<Type2, vespalib::DefaultAlloc> Type2Vector;
-    typedef vespalib::Array<Type3, vespalib::DefaultAlloc> Type3Vector;
+    typedef vespalib::Array<Type0> Type0Vector;
+    typedef vespalib::Array<Type1> Type1Vector;
+    typedef vespalib::Array<Type2> Type2Vector;
+    typedef vespalib::Array<Type3> Type3Vector;
     Type0Vector _values0;
     Type1Vector _values1;
     Type2Vector _values2;
diff --git a/storageapi/src/vespa/storageapi/mbusprot/storagereply.cpp b/storageapi/src/vespa/storageapi/mbusprot/storagereply.cpp
index b9fde51eaef..0165348968e 100644
--- a/storageapi/src/vespa/storageapi/mbusprot/storagereply.cpp
+++ b/storageapi/src/vespa/storageapi/mbusprot/storagereply.cpp
@@ -4,13 +4,17 @@
 
 #include <vespa/storageapi/mbusprot/storagecommand.h>
 
+using vespalib::DefaultAlloc;
+using vespalib::alloc::Alloc;
+using vespalib::IllegalStateException;
+
 namespace storage {
 namespace mbusprot {
 
 StorageReply::StorageReply(const mbus::BlobRef& data,
                            const ProtocolSerialization& serializer)
     : _serializer(&serializer),
-      _buffer(data.size()),
+      _buffer(DefaultAlloc::create(data.size())),
       _mbusType(0),
       _reply()
 {
@@ -38,20 +42,16 @@ StorageReply::deserialize() const
     StorageReply& reply(const_cast<StorageReply&>(*this));
     mbus::Message::UP msg(reply.getMessage());
     if (msg.get() == 0) {
-        throw vespalib::IllegalStateException(
-                "Cannot deserialize storage reply before message have been set",
-                VESPA_STRLOC);
+        throw IllegalStateException("Cannot deserialize storage reply before message have been set", VESPA_STRLOC);
     }
     const StorageCommand* cmd(dynamic_cast<const StorageCommand*>(msg.get()));
     reply.setMessage(std::move(msg));
     if (cmd == 0) {
-        throw vespalib::IllegalStateException(
-                "Storage reply get message did not return a storage command",
-                VESPA_STRLOC);
+        throw IllegalStateException("Storage reply get message did not return a storage command", VESPA_STRLOC);
     }
     mbus::BlobRef blobRef(static_cast<char *>(_buffer.get()), _buffer.size());
     _reply = _serializer->decodeReply(blobRef, *cmd->getCommand())->getReply();
-    vespalib::DefaultAlloc().swap(_buffer);
+    Alloc().swap(_buffer);
 }
 
 } // mbusprot
diff --git a/storageapi/src/vespa/storageapi/mbusprot/storagereply.h b/storageapi/src/vespa/storageapi/mbusprot/storagereply.h
index 52f7efc50cc..429833bf08b 100644
--- a/storageapi/src/vespa/storageapi/mbusprot/storagereply.h
+++ b/storageapi/src/vespa/storageapi/mbusprot/storagereply.h
@@ -11,7 +11,7 @@ namespace mbusprot {
 
 class StorageReply : public mbus::Reply, public StorageMessage {
     const ProtocolSerialization* _serializer;
-    mutable vespalib::DefaultAlloc _buffer;
+    mutable vespalib::alloc::Alloc _buffer;
     uint32_t _mbusType;
     mutable api::StorageReply::SP _reply;
 
diff --git a/storageapi/src/vespa/storageapi/message/bucket.h b/storageapi/src/vespa/storageapi/message/bucket.h
index 28b3ba36f30..b47aa01c63e 100644
--- a/storageapi/src/vespa/storageapi/message/bucket.h
+++ b/storageapi/src/vespa/storageapi/message/bucket.h
@@ -409,7 +409,7 @@ public:
             : _bucketId(id), _info(info) {}
         friend std::ostream& operator<<(std::ostream& os, const Entry&);
     };
-    typedef vespalib::Array<Entry, vespalib::DefaultAlloc> EntryVector;
+    typedef vespalib::Array<Entry> EntryVector;
 private:
     EntryVector _buckets;
 
diff --git a/vespalib/src/tests/alloc/allocate_and_core.cpp b/vespalib/src/tests/alloc/allocate_and_core.cpp
index 2cb4d447fd1..f0a0669eb42 100644
--- a/vespalib/src/tests/alloc/allocate_and_core.cpp
+++ b/vespalib/src/tests/alloc/allocate_and_core.cpp
@@ -1,14 +1,14 @@
 // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 #include <vespa/vespalib/util/alloc.h>
 
-using namespace vespalib;
+using namespace vespalib::alloc;
 
 int main(int argc, char *argv[]) {
     (void) argc;
     (void) argv;
-    MMapAlloc small( 0x400000); //4M
+    Alloc small(MMapAllocFactory::create(0x400000)); //4M
     memset(small.get(), 0x55, small.size());
-    MMapAlloc large(0x4000000); //640M
+    Alloc large(MMapAllocFactory::create(0x4000000)); //640M
     memset(large.get(), 0x66, large.size());
     assert(false);
 }
diff --git a/vespalib/src/vespa/vespalib/data/memorydatastore.cpp b/vespalib/src/vespa/vespalib/data/memorydatastore.cpp
index e6b22aa9e3f..791ea0cea50 100644
--- a/vespalib/src/vespa/vespalib/data/memorydatastore.cpp
+++ b/vespalib/src/vespa/vespalib/data/memorydatastore.cpp
@@ -3,13 +3,15 @@
 
 namespace vespalib {
 
-MemoryDataStore::MemoryDataStore(size_t initialSize, Lock * lock) :
+using alloc::Alloc;
+
+MemoryDataStore::MemoryDataStore(Alloc && initialAlloc, Lock * lock) :
     _buffers(),
     _writePos(0),
     _lock(lock)
 {
     _buffers.reserve(24);
-    _buffers.emplace_back(initialSize);
+    _buffers.emplace_back(std::move(initialAlloc));
 }
 
 MemoryDataStore::~MemoryDataStore()
@@ -26,7 +28,7 @@ MemoryDataStore::push_back(const void * data, const size_t sz)
     const Alloc & b = _buffers.back();
     if ((sz + _writePos) > b.size()) {
         size_t newSize(std::max(sz, _buffers.back().size()*2));
-        _buffers.emplace_back(newSize);
+        _buffers.emplace_back(b.create(newSize));
         _writePos = 0;
     }
     Alloc & buf = _buffers.back();
@@ -39,7 +41,7 @@ MemoryDataStore::push_back(const void * data, const size_t sz)
 
 VariableSizeVector::VariableSizeVector(size_t initialSize) :
     _vector(),
-    _store(initialSize)
+    _store(DefaultAlloc::create(initialSize))
 {
 }
 
diff --git a/vespalib/src/vespa/vespalib/data/memorydatastore.h b/vespalib/src/vespa/vespalib/data/memorydatastore.h
index 3b345cb29bd..b61fa3665ad 100644
--- a/vespalib/src/vespa/vespalib/data/memorydatastore.h
+++ b/vespalib/src/vespa/vespalib/data/memorydatastore.h
@@ -23,7 +23,7 @@ public:
     private:
         void   * _data;
     };
-    MemoryDataStore(size_t initialSize=256, Lock * lock=nullptr);
+    MemoryDataStore(alloc::Alloc && initialAlloc=DefaultAlloc::create(256), Lock * lock=nullptr);
     MemoryDataStore(const MemoryDataStore &) = delete;
     MemoryDataStore & operator = (const MemoryDataStore &) = delete;
     ~MemoryDataStore();
@@ -38,7 +38,7 @@ public:
         _buffers.clear();
     }
 private:
-    std::vector<DefaultAlloc> _buffers;
+    std::vector<alloc::Alloc> _buffers;
     size_t _writePos;
     Lock * _lock;
 };
diff --git a/vespalib/src/vespa/vespalib/objects/nbostream.h b/vespalib/src/vespa/vespalib/objects/nbostream.h
index af5ac47fcb5..cb15db018fc 100644
--- a/vespalib/src/vespa/vespalib/objects/nbostream.h
+++ b/vespalib/src/vespa/vespalib/objects/nbostream.h
@@ -36,7 +36,8 @@ private:
 class nbostream
 {
  public:
-    typedef Array<char, DefaultAlloc> Buffer;
+    using Buffer = Array<char>;
+    using Alloc = alloc::Alloc;
     enum State { ok=0, eof=0x01};
     nbostream(size_t initialSize=1024) :
         _wbuf(),
@@ -59,7 +60,7 @@ class nbostream
     {
     }
 
-    nbostream(DefaultAlloc && buf, size_t sz) :
+    nbostream(Alloc && buf, size_t sz) :
         _wbuf(std::move(buf), sz),
         _rbuf(&_wbuf[0], sz),
         _rp(0),
diff --git a/vespalib/src/vespa/vespalib/stllike/hashtable.h b/vespalib/src/vespa/vespalib/stllike/hashtable.h
index e038c9f40d9..a1eeb289c31 100644
--- a/vespalib/src/vespa/vespalib/stllike/hashtable.h
+++ b/vespalib/src/vespa/vespalib/stllike/hashtable.h
@@ -132,7 +132,7 @@ class hashtable : public hashtable_base
 private:
     using Node=hash_node<Value>;
 protected:
-    typedef vespalib::Array<Node, vespalib::DefaultAlloc > NodeStore;
+    typedef vespalib::Array<Node> NodeStore;
     virtual void move(NodeStore && oldStore);
 public:
     class const_iterator;
diff --git a/vespalib/src/vespa/vespalib/util/alloc.cpp b/vespalib/src/vespa/vespalib/util/alloc.cpp
index 552ac547dae..d719d7386bb 100644
--- a/vespalib/src/vespa/vespalib/util/alloc.cpp
+++ b/vespalib/src/vespa/vespalib/util/alloc.cpp
@@ -88,11 +88,11 @@ alloc::HeapAllocator _G_heapAllocatorDefault;
 alloc::AlignedHeapAllocator _G_4KalignedHeapAllocator(4096);
 alloc::AlignedHeapAllocator _G_512BalignedHeapAllocator(512);
 alloc::MMapAllocator _G_mmapAllocatorDefault;
-alloc::AutoAllocator _G_autoAllocatorDefault(alloc::MMapAllocator::HUGEPAGE_SIZE);
-alloc::AutoAllocator _G_2PautoAllocatorDefault(2 * alloc::MMapAllocator::HUGEPAGE_SIZE);
-alloc::AutoAllocator _G_4PautoAllocatorDefault(4 * alloc::MMapAllocator::HUGEPAGE_SIZE);
-alloc::AutoAllocator _G_8PautoAllocatorDefault(8 * alloc::MMapAllocator::HUGEPAGE_SIZE);
-alloc::AutoAllocator _G_16PautoAllocatorDefault(16 * alloc::MMapAllocator::HUGEPAGE_SIZE);
+alloc::AutoAllocator _G_autoAllocatorDefault(alloc::MMapAllocator::HUGEPAGE_SIZE, 0);
+alloc::AutoAllocator _G_2PautoAllocatorDefault(2 * alloc::MMapAllocator::HUGEPAGE_SIZE, 0);
+alloc::AutoAllocator _G_4PautoAllocatorDefault(4 * alloc::MMapAllocator::HUGEPAGE_SIZE, 0);
+alloc::AutoAllocator _G_8PautoAllocatorDefault(8 * alloc::MMapAllocator::HUGEPAGE_SIZE, 0);
+alloc::AutoAllocator _G_16PautoAllocatorDefault(16 * alloc::MMapAllocator::HUGEPAGE_SIZE, 0);
 
 }
 
@@ -134,7 +134,7 @@ MemoryAllocator & AutoAllocator::get16P() {
     return _G_16PautoAllocatorDefault;
 }
 
-void * HeapAllocator::alloc(size_t sz) {
+void * HeapAllocator::alloc(size_t sz) const {
     return salloc(sz);
 }
 
@@ -142,7 +142,7 @@ void * HeapAllocator::salloc(size_t sz) {
     return (sz > 0) ? malloc(sz) : 0;
 }
 
-void HeapAllocator::free(void * p, size_t sz) {
+void HeapAllocator::free(void * p, size_t sz) const {
     sfree(p, sz);
 }
 
@@ -150,19 +150,17 @@ void HeapAllocator::sfree(void * p, size_t sz) {
     (void) sz; if (p) { ::free(p); }
 }
 
-void * AlignedHeapAllocator::alloc(size_t sz) {
+void * AlignedHeapAllocator::alloc(size_t sz) const {
     if (!sz) { return 0; }
     void* ptr;
     int result = posix_memalign(&ptr, _alignment, sz);
     if (result != 0) {
-        throw IllegalArgumentException(
-                make_string("posix_memalign(%zu, %zu) failed with code %d",
-                            sz, _alignment, result));
+        throw IllegalArgumentException(make_string("posix_memalign(%zu, %zu) failed with code %d", sz, _alignment, result));
     }
     return ptr;
 }
 
-void * MMapAllocator::alloc(size_t sz) {
+void * MMapAllocator::alloc(size_t sz) const {
     return salloc(sz);
 }
 
@@ -217,7 +215,7 @@ void * MMapAllocator::salloc(size_t sz)
     return buf;
 }
 
-void MMapAllocator::free(void * buf, size_t sz) {
+void MMapAllocator::free(void * buf, size_t sz) const {
     sfree(buf, sz);
 }
 
@@ -236,16 +234,20 @@ void MMapAllocator::sfree(void * buf, size_t sz)
     }
 }
 
-void * AutoAllocator::alloc(size_t sz) {
+void * AutoAllocator::alloc(size_t sz) const {
     if (useMMap(sz)) {
         sz = roundUpToHugePages(sz);
         return MMapAllocator::salloc(sz);
     } else {
-        return HeapAllocator::salloc(sz);
+        if (_alignment == 0) {
+            return HeapAllocator::salloc(sz);
+        } else {
+            return AlignedHeapAllocator(_alignment).alloc(sz);
+        }
     }
 }
 
-void AutoAllocator::free(void *p, size_t sz) {
+void AutoAllocator::free(void *p, size_t sz) const {
     if (useMMap(sz)) {
         return MMapAllocator::sfree(p, sz);
     } else {
@@ -253,5 +255,32 @@ void AutoAllocator::free(void *p, size_t sz) {
     }
 }
 
+Alloc
+MMapAllocFactory::create(size_t sz)
+{
+    return Alloc(&MMapAllocator::getDefault(), sz);
 }
+
+Alloc
+AutoAllocFactory::create(size_t sz, size_t mmapLimit, size_t alignment)
+{
+    if (alignment == 0) {
+        if (mmapLimit <= MMapAllocator::HUGEPAGE_SIZE) {
+            return Alloc(&AutoAllocator::getDefault(), sz);
+        } else if (mmapLimit <= 2*MMapAllocator::HUGEPAGE_SIZE) {
+            return Alloc(&AutoAllocator::get2P(), sz);
+        } else if (mmapLimit <= 4*MMapAllocator::HUGEPAGE_SIZE) {
+            return Alloc(&AutoAllocator::get4P(), sz);
+        } else if (mmapLimit <= 8*MMapAllocator::HUGEPAGE_SIZE) {
+            return Alloc(&AutoAllocator::get8P(), sz);
+        } else {
+            return Alloc(&AutoAllocator::get16P(), sz);
+        }
+    } else {
+        abort();
+    }
+}
+
+}
+
 }
diff --git a/vespalib/src/vespa/vespalib/util/alloc.h b/vespalib/src/vespa/vespalib/util/alloc.h
index 6cb70ee5f55..23f4923b3c5 100644
--- a/vespalib/src/vespa/vespalib/util/alloc.h
+++ b/vespalib/src/vespa/vespalib/util/alloc.h
@@ -17,14 +17,14 @@ public:
     MemoryAllocator & operator = (const MemoryAllocator &) = delete;
     MemoryAllocator() { }
     virtual ~MemoryAllocator() { }
-    virtual void * alloc(size_t sz) = 0;
-    virtual void free(void * buf, size_t sz) = 0;
+    virtual void * alloc(size_t sz) const = 0;
+    virtual void free(void * buf, size_t sz) const = 0;
 };
 
 class HeapAllocator : public MemoryAllocator {
 public:
-    void * alloc(size_t sz) override;
-    void free(void * buf, size_t sz) override;
+    void * alloc(size_t sz) const override;
+    void free(void * buf, size_t sz) const override;
     static void * salloc(size_t sz);
     static void sfree(void * buf, size_t sz);
     static MemoryAllocator & getDefault();
@@ -33,7 +33,7 @@ public:
 class AlignedHeapAllocator : public HeapAllocator {
 public:
     AlignedHeapAllocator(size_t alignment) : _alignment(alignment) { }
-    void * alloc(size_t sz) override;
+    void * alloc(size_t sz) const override;
     static MemoryAllocator & get4K();
     static MemoryAllocator & get512B();
 private:
@@ -43,8 +43,8 @@ private:
 class MMapAllocator : public MemoryAllocator {
 public:
     enum {HUGEPAGE_SIZE=0x200000};
-    void * alloc(size_t sz) override;
-    void free(void * buf, size_t sz) override;
+    void * alloc(size_t sz) const override;
+    void free(void * buf, size_t sz) const override;
     static void * salloc(size_t sz);
     static void sfree(void * buf, size_t sz);
     static size_t roundUpToHugePages(size_t sz) {
@@ -55,35 +55,35 @@ public:
 
 class AutoAllocator : public MemoryAllocator {
 public:
-    AutoAllocator(size_t mmapLimit) : _mmapLimit(mmapLimit) { }
-    void * alloc(size_t sz) override;
-    void free(void * buf, size_t sz) override;
+    AutoAllocator(size_t mmapLimit, size_t alignment) : _mmapLimit(mmapLimit), _alignment(alignment) { }
+    void * alloc(size_t sz) const override;
+    void free(void * buf, size_t sz) const override;
     static MemoryAllocator & getDefault();
     static MemoryAllocator & get2P();
     static MemoryAllocator & get4P();
     static MemoryAllocator & get8P();
     static MemoryAllocator & get16P();
 private:
-    size_t roundUpToHugePages(size_t sz) {
+    size_t roundUpToHugePages(size_t sz) const {
         return (_mmapLimit >= MMapAllocator::HUGEPAGE_SIZE)
             ? MMapAllocator::roundUpToHugePages(sz)
             : sz;
     }
-    bool useMMap(size_t sz) { return (sz >= _mmapLimit); }
+    bool useMMap(size_t sz) const { return (sz >= _mmapLimit); }
     size_t _mmapLimit;
+    size_t _alignment;
 };
 
-}
 
-inline size_t roundUp2inN(size_t minimum) {
-    return 2ul << Optimized::msbIdx(minimum - 1);
-}
 /**
- * This is an allocated buffer interface that does not accept virtual inheritance.
+ * This represents an allocation.
+ * It can be created, moved, swapped and resized.
+ * The allocation strategy is decided upon creation.
 **/
 class Alloc
 {
 public:
+    using MemoryAllocator = alloc::MemoryAllocator;
     size_t size() const { return _sz; }
     void * get() { return _buf; }
     const void * get() const { return _buf; }
@@ -91,107 +91,66 @@ public:
     const void * operator -> () const { return _buf; }
     Alloc(const Alloc &) = delete;
     Alloc & operator = (const Alloc &) = delete;
-protected:
     Alloc(Alloc && rhs) :
         _buf(rhs._buf),
-        _sz(rhs._sz)
+        _sz(rhs._sz),
+        _allocator(rhs._allocator)
     {
         rhs._buf = nullptr;
         rhs._sz = 0;
+        rhs._allocator = 0;
     }
     Alloc & operator=(Alloc && rhs) {
         if (this != & rhs) {
-            internalSwap(rhs);
+            swap(rhs);
         }
         return *this;
     }
-    Alloc(void * buf, size_t sz) : _buf(buf), _sz(sz) { }
-    ~Alloc() { _buf = 0; }
-    void internalSwap(Alloc & rhs) {
+    Alloc() : _buf(nullptr), _sz(0), _allocator(nullptr) { }
+    Alloc(const MemoryAllocator * allocator, size_t sz) : _buf(allocator->alloc(sz)), _sz(sz), _allocator(allocator) { }
+    ~Alloc() { 
+        if (_buf != nullptr) {
+            _allocator->free(_buf, _sz);
+            _buf = nullptr;
+        }
+    }
+    void swap(Alloc & rhs) {
         std::swap(_buf, rhs._buf);
         std::swap(_sz, rhs._sz);
+        std::swap(_allocator, rhs._allocator);
     }
-private:
-    void * _buf;
-    size_t _sz;
+    Alloc create(size_t sz) const {
+        return Alloc(_allocator, sz);
+    }
+protected:
+    void alloc(const MemoryAllocator * allocator, size_t sz) {
+        assert(_buf == nullptr);
+        _allocator = allocator;
+        _sz = sz;
+        _buf = allocator->alloc(sz);
+    }
+    void                  * _buf;
+    size_t                  _sz;
+    const MemoryAllocator * _allocator;
 };
 
-class HeapAlloc : public Alloc
+class HeapAllocFactory
 {
 public:
-    typedef std::unique_ptr<HeapAlloc> UP;
-    HeapAlloc() : Alloc(NULL, 0) { }
-    HeapAlloc(size_t sz) : Alloc(HeapAlloc::alloc(sz), sz) { }
-    ~HeapAlloc() { HeapAlloc::free(get(), size()); }
-    HeapAlloc(HeapAlloc && rhs) : Alloc(std::move(rhs)) { }
-
-    HeapAlloc & operator=(HeapAlloc && rhs) {
-        Alloc::operator=(std::move(rhs));
-        return *this;
-    }
-    void swap(HeapAlloc & rhs) { internalSwap(rhs); }
-public:
-    static void * alloc(size_t sz) { return alloc::HeapAllocator::getDefault().alloc(sz); }
-    static void free(void * buf, size_t sz) { alloc::HeapAllocator::getDefault().free(buf, sz); }
+    static Alloc create(size_t sz=0);
 };
 
-class AlignedHeapAlloc : public Alloc
+class AlignedHeapAllocFactory
 {
 public:
-    typedef std::unique_ptr<AlignedHeapAlloc> UP;
-    AlignedHeapAlloc() : Alloc(NULL, 0) { }
-    AlignedHeapAlloc(size_t sz, size_t alignment)
-        : Alloc(AlignedHeapAlloc::alloc(sz, alignment), sz) { }
-    AlignedHeapAlloc(AlignedHeapAlloc && rhs) : Alloc(std::move(rhs)) { }
-
-    AlignedHeapAlloc & operator=(AlignedHeapAlloc && rhs) {
-        Alloc::operator=(std::move(rhs));
-        return *this;
-    }
-    ~AlignedHeapAlloc() { AlignedHeapAlloc::free(get(), size()); }
-    void swap(AlignedHeapAlloc & rhs) { internalSwap(rhs); }
-public:
-    static void * alloc(size_t sz, size_t alignment) { return alloc::AlignedHeapAllocator(alignment).alloc(sz); }
-    static void free(void * buf, size_t sz) { return alloc::AlignedHeapAllocator(0).free(buf, sz); }
+    static Alloc create(size_t sz, size_t alignment);
 };
 
-
-class MMapAlloc : public Alloc
+class MMapAllocFactory
 {
 public:
     enum {HUGEPAGE_SIZE=0x200000};
-    typedef std::unique_ptr<MMapAlloc> UP;
-    MMapAlloc() : Alloc(NULL, 0) { }
-    MMapAlloc(size_t sz) : Alloc(MMapAlloc::alloc(sz), sz) { }
-    MMapAlloc(MMapAlloc && rhs) : Alloc(std::move(rhs)) { }
-
-    MMapAlloc & operator=(MMapAlloc && rhs) {
-        Alloc::operator=(std::move(rhs));
-        return *this;
-    }
-    ~MMapAlloc() { MMapAlloc::free(get(), size()); }
-    void swap(MMapAlloc & rhs) { internalSwap(rhs); }
-public:
-    static void * alloc(size_t sz) { return alloc::MMapAllocator::getDefault().alloc(sz); }
-    static void free(void * buf, size_t sz) { alloc::MMapAllocator::getDefault().free(buf, sz); }
-};
-
-// Alignment requirement is != 0, use posix_memalign
-template <size_t Alignment>
-struct ChooseHeapAlloc
-{
-    static inline void* alloc(size_t sz) {
-        return AlignedHeapAlloc::alloc(sz, Alignment);
-    }
-};
-
-// No alignment required, use regular malloc
-template <>
-struct ChooseHeapAlloc<0>
-{
-    static inline void* alloc(size_t sz) {
-        return HeapAlloc::alloc(sz);
-    }
+    static Alloc create(size_t sz=0);
 };
 
 /**
@@ -199,53 +158,19 @@ struct ChooseHeapAlloc<0>
  * is always used when size is above limit.
  */
 
-template <size_t Lim=MMapAlloc::HUGEPAGE_SIZE, size_t Alignment=0>
-class AutoAlloc : public Alloc
+class AutoAllocFactory 
 {
 public:
-    typedef std::unique_ptr<AutoAlloc> UP;
-    typedef vespalib::LinkedPtr<AutoAlloc> LP;
-    AutoAlloc() : Alloc(NULL, 0) { }
-    AutoAlloc(size_t sz)
-        : Alloc(useMMap(sz)
-                    ? MMapAlloc::alloc(roundUpToHugePages(sz))
-                    : ChooseHeapAlloc<Alignment>::alloc(sz),
-                useMMap(sz)
-                    ? roundUpToHugePages(sz)
-                    : sz)
-    { }
-    AutoAlloc(AutoAlloc && rhs) : Alloc(std::move(rhs)) { }
-
-    AutoAlloc & operator=(AutoAlloc && rhs) {
-        Alloc::operator=(std::move(rhs));
-        return *this;
-    }
-
-    ~AutoAlloc() {
-        if (useMMap(size())) {
-            MMapAlloc::free(get(), size());
-        } else {
-            HeapAlloc::free(get(), size());
-        }
-    }
-    void swap(AutoAlloc & rhs) { internalSwap(rhs); }
-private:
-    static size_t roundUpToHugePages(size_t sz) {
-        return (Lim >= MMapAlloc::HUGEPAGE_SIZE)
-            ? (sz+(MMapAlloc::HUGEPAGE_SIZE-1)) & ~(MMapAlloc::HUGEPAGE_SIZE-1)
-            : sz;
-    }
-    static bool useMMap(size_t sz) { return (sz >= Lim); }
+    static Alloc create(size_t sz=0, size_t mmapLimit=MMapAllocator::HUGEPAGE_SIZE, size_t alignment=0);
 };
 
-template <size_t Lim>
-inline void swap(AutoAlloc<Lim> & a, AutoAlloc<Lim> & b) { a.swap(b); }
+}
 
-inline void swap(HeapAlloc & a, HeapAlloc & b) { a.swap(b); }
-inline void swap(AlignedHeapAlloc & a, AlignedHeapAlloc & b) { a.swap(b); }
-inline void swap(MMapAlloc & a, MMapAlloc & b) { a.swap(b); }
+inline size_t roundUp2inN(size_t minimum) {
+    return 2ul << Optimized::msbIdx(minimum - 1);
+}
 
-typedef AutoAlloc<> DefaultAlloc;
+using DefaultAlloc = alloc::AutoAllocFactory;
 
 }
 
diff --git a/vespalib/src/vespa/vespalib/util/array.h b/vespalib/src/vespa/vespalib/util/array.h
index 8f40d4de0c7..f2546e46e22 100644
--- a/vespalib/src/vespa/vespalib/util/array.h
+++ b/vespalib/src/vespa/vespalib/util/array.h
@@ -35,7 +35,7 @@ private:
 * it generates more efficient code.
 * It only supports simple objects without constructors/destructors.
 **/
-template <typename T, typename B=HeapAlloc>
+template <typename T>
 class Array {
 public:
     class reverse_iterator {
@@ -101,18 +101,19 @@ public:
         friend size_t operator -(const_reverse_iterator a, const_reverse_iterator b) { return b._p - a._p; }
         const T * _p;
     };
+    using Alloc = alloc::Alloc;
     typedef const T * const_iterator;
     typedef T * iterator;
     typedef const T & const_reference;
     typedef T value_type;
     typedef size_t size_type;
 
-    Array() : _array(), _sz(0) { }
-    Array(size_t sz);
-    Array(B && buf, size_t sz);
+    Array(const Alloc & initial=DefaultAlloc::create()) : _array(initial.create(0)), _sz(0) { }
+    Array(size_t sz, const Alloc & initial=DefaultAlloc::create());
+    Array(Alloc && buf, size_t sz);
     Array(Array &&rhs);
-    Array(size_t sz, T value);
-    Array(const_iterator begin, const_iterator end);
+    Array(size_t sz, T value, const Alloc & initial=DefaultAlloc::create());
+    Array(const_iterator begin, const_iterator end, const Alloc & initial=DefaultAlloc::create());
     Array(const Array & rhs);
     Array & operator =(const Array & rhs) {
         if (&rhs != this) {
@@ -185,7 +186,7 @@ private:
             reserve(roundUp2inN(n));
         }
     }
-    B        _array;
+    Alloc  _array;
     size_t _sz;
 };
 
@@ -236,16 +237,16 @@ void construct(T * dest, size_t sz, T val, std::tr1::true_type)
     }
 }
 
-template <typename T, typename B>
-Array<T, B>::Array(const Array & rhs)
-    : _array(rhs.size() * sizeof(T)),
+template <typename T>
+Array<T>::Array(const Array & rhs)
+    : _array(rhs._array.create(rhs.size() * sizeof(T))),
       _sz(rhs.size())
 {
     construct(array(0), rhs.array(0), _sz, std::tr1::has_trivial_destructor<T>());
 }
 
-template <typename T, typename B>
-bool Array<T, B>::operator ==(const Array & rhs) const
+template <typename T>
+bool Array<T>::operator ==(const Array & rhs) const
 {
     bool retval(size() == rhs.size());
     for (size_t i(0); retval && (i < _sz); i++) {
@@ -256,8 +257,8 @@ bool Array<T, B>::operator ==(const Array & rhs) const
     return retval;
 }
 
-template <typename T, typename B>
-void Array<T, B>::resize(size_t n)
+template <typename T>
+void Array<T>::resize(size_t n)
 {
     if (n > capacity()) {
         reserve(n);
@@ -285,69 +286,68 @@ void move(T * dest, const T * source, size_t sz, std::tr1::true_type)
     memcpy(dest, source, sz*sizeof(T));
 }
 
-template <typename T, typename B>
-void Array<T, B>::increase(size_t n)
+template <typename T>
+void Array<T>::increase(size_t n)
 {
-    B newArray(sizeof(T)*n);
+    Alloc newArray(_array.create(sizeof(T)*n));
     if (capacity() > 0) {
         move(static_cast<T *>(newArray.get()), array(0), _sz, std::tr1::has_trivial_destructor<T>());
     }
     _array.swap(newArray);
 }
 
-template <typename T, typename B>
-Array<T, B>::Array(B && buf, size_t sz) :
+template <typename T>
+Array<T>::Array(Alloc && buf, size_t sz) :
     _array(std::move(buf)),
     _sz(sz)
 {
 }
 
 
-template <typename T, typename B>
-Array<T, B>::Array(Array &&rhs)
+template <typename T>
+Array<T>::Array(Array &&rhs)
     :  _array(std::move(rhs._array)),
        _sz(rhs._sz)
 {
     rhs._sz = 0;
 }
 
-template <typename T, typename B>
-Array<T, B>::Array(size_t sz) :
-    _array(sz * sizeof(T)),
+template <typename T>
+Array<T>::Array(size_t sz, const Alloc & initial) :
+    _array(initial.create(sz * sizeof(T))),
     _sz(sz)
 {
     construct(array(0), _sz, std::tr1::has_trivial_destructor<T>());
 }
 
-template <typename T, typename B>
-Array<T, B>::Array(size_t sz, T value) :
-    _array(sz * sizeof(T)),
+template <typename T>
+Array<T>::Array(size_t sz, T value, const Alloc & initial) :
+    _array(initial.create(sz * sizeof(T))),
     _sz(sz)
 {
     construct(array(0), _sz, value, std::tr1::has_trivial_destructor<T>());
 }
 
-template <typename T, typename B>
-Array<T, B>::Array(const_iterator begin_, const_iterator end_) :
-    _array(begin_ != end_ ? sizeof(T) * (end_-begin_) : 0),
+template <typename T>
+Array<T>::Array(const_iterator begin_, const_iterator end_, const Alloc & initial) :
+    _array(initial.create(begin_ != end_ ? sizeof(T) * (end_-begin_) : 0)),
     _sz(end_-begin_)
 {
     construct(array(0), begin_, _sz, std::tr1::has_trivial_destructor<T>());
 }
 
-template <typename T, typename B>
-Array<T, B>::~Array()
+template <typename T>
+Array<T>::~Array()
 {
     cleanup();
 }
 
-template <typename T, typename B>
-void Array<T, B>::cleanup()
+template <typename T>
+void Array<T>::cleanup()
 {
     std::_Destroy(array(0), array(_sz));
     _sz = 0;
-    B tmp;
-    tmp.swap(_array);
+    Alloc().swap(_array);
 }
 
 }
diff --git a/vsm/src/vespa/vsm/searcher/fieldsearcher.h b/vsm/src/vespa/vsm/searcher/fieldsearcher.h
index 597baea1b67..73ad8a9f28a 100644
--- a/vsm/src/vespa/vsm/searcher/fieldsearcher.h
+++ b/vsm/src/vespa/vsm/searcher/fieldsearcher.h
@@ -18,7 +18,7 @@ typedef size_t termsize_t;
 #endif
 
 typedef ucs4_t cmptype_t;
-typedef vespalib::Array<cmptype_t, vespalib::DefaultAlloc> SearcherBuf;
+typedef vespalib::Array<cmptype_t> SearcherBuf;
 typedef std::shared_ptr<SearcherBuf> SharedSearcherBuf;
 typedef std::vector<char> CharVector;