- Unify on uint32_t as type for thread id.

- use std::atomic_flag instead of volatile bool.
- Minor code health like NULL -> nullptr and '= default'.

10 files changed, 37 insertions, 43 deletions

diff --git a/vespamalloc/src/vespamalloc/malloc/datasegment.h b/vespamalloc/src/vespamalloc/malloc/datasegment.h
index ab23f2207e3..1ad4887c033 100644
--- a/vespamalloc/src/vespamalloc/malloc/datasegment.h
+++ b/vespamalloc/src/vespamalloc/malloc/datasegment.h
@@ -28,7 +28,7 @@ public:
     static size_t adjustedClassSize(SizeClassT sc)  { return (sc > 0x400) ? (sc - 0x400) << 16 : sc; }
     size_t dataSize()                         const { return (const char*)end() - (const char*)start(); }
     size_t textSize()                         const { return size_t(start()); }
-    size_t infoThread(FILE * os, int level, int thread, SizeClassT sct) const __attribute__((noinline));
+    size_t infoThread(FILE * os, int level, uint32_t thread, SizeClassT sct) const __attribute__((noinline));
     void info(FILE * os, size_t level) __attribute__((noinline));
     void setupLog(size_t noMemLogLevel, size_t bigMemLogLevel,
                   size_t bigLimit, size_t bigIncrement,
diff --git a/vespamalloc/src/vespamalloc/malloc/datasegment.hpp b/vespamalloc/src/vespamalloc/malloc/datasegment.hpp
index 840088fd843..366747ef880 100644
--- a/vespamalloc/src/vespamalloc/malloc/datasegment.hpp
+++ b/vespamalloc/src/vespamalloc/malloc/datasegment.hpp
@@ -48,19 +48,19 @@ void * DataSegment<MemBlockPtrT>::getBlock(size_t & oldBlockSize, SizeClassT sc)
     oldBlockSize = ((oldBlockSize + (minBlockSize-1))/minBlockSize)*minBlockSize;
     size_t numBlocks((oldBlockSize + (BlockSize-1))/BlockSize);
     size_t blockSize = BlockSize * numBlocks;
-    void * newBlock(NULL);
+    void * newBlock(nullptr);
     {
         Guard sync(_mutex);
         newBlock = _freeList.sub(numBlocks);
-        if ( newBlock == NULL ) {
+        if ( newBlock == nullptr ) {
             newBlock = _unMappedList.sub(numBlocks);
-            if ( newBlock == NULL ) {
+            if ( newBlock == nullptr ) {
                 size_t nextBlock(blockId(end()));
                 size_t startBlock = _freeList.lastBlock(nextBlock);
                 if (startBlock) {
                     size_t adjustedBlockSize = blockSize - BlockSize*(nextBlock-startBlock);
                     newBlock = _osMemory.get(adjustedBlockSize);
-                    if (newBlock != NULL) {
+                    if (newBlock != nullptr) {
                         assert (newBlock == fromBlockId(nextBlock));
                         _freeList.removeLastBlock();
                         newBlock = fromBlockId(startBlock);
@@ -79,9 +79,9 @@ void * DataSegment<MemBlockPtrT>::getBlock(size_t & oldBlockSize, SizeClassT sc)
         }
     }
     if (newBlock == (void *) -1) {
-        newBlock = NULL;
+        newBlock = nullptr;
         blockSize = 0;
-    } else if (newBlock == NULL) {
+    } else if (newBlock == nullptr) {
         blockSize = 0;
     } else {
         assert(blockId(newBlock)+numBlocks < BlockCount);
@@ -95,7 +95,7 @@ void * DataSegment<MemBlockPtrT>::getBlock(size_t & oldBlockSize, SizeClassT sc)
         }
     }
     oldBlockSize = blockSize;
-    if (newBlock == NULL) {
+    if (newBlock == nullptr) {
         static int recurse = 0;
         if (recurse++ == 0) {
             perror("Failed extending datasegment: ");
@@ -103,7 +103,7 @@ void * DataSegment<MemBlockPtrT>::getBlock(size_t & oldBlockSize, SizeClassT sc)
             MemBlockPtrT::dumpInfo(_noMemLogLevel);
             sleep(2);
         }
-        return NULL;
+        return nullptr;
     }
     checkAndLogBigSegment();
     return newBlock;
@@ -162,7 +162,7 @@ void DataSegment<MemBlockPtrT>::returnBlock(void *ptr)
 }
 
 template<typename MemBlockPtrT>
-size_t DataSegment<MemBlockPtrT>::infoThread(FILE * os, int level, int thread, SizeClassT sct) const
+size_t DataSegment<MemBlockPtrT>::infoThread(FILE * os, int level, uint32_t thread, SizeClassT sct) const
 {
     typedef CallGraph<typename MemBlockPtrT::Stack, 0x10000, Index> CallGraphLT;
     size_t usedCount(0);
@@ -308,7 +308,7 @@ void DataSegment<MemBlockPtrT>::FreeListT<MaxCount>::add(size_t startIndex)
     size_t numBlocks(_blockList[startIndex].freeChainLength());
     for (i=0; (i < _count) && (_freeStartIndex[i] < startIndex); i++) { }
     size_t prevIndex(0), nextIndex(0);
-    BlockT * prev(NULL), * next(NULL);
+    BlockT * prev(nullptr), * next(nullptr);
     if (i > 0) {
         prevIndex = _freeStartIndex[i-1];
         prev = & _blockList[prevIndex];
@@ -352,7 +352,7 @@ template<typename MemBlockPtrT>
 template <int MaxCount>
 void * DataSegment<MemBlockPtrT>::FreeListT<MaxCount>::sub(size_t numBlocks)
 {
-    void * block(NULL);
+    void * block(nullptr);
     size_t bestFitIndex(_count);
     int bestLeft(INT_MAX);
     for(size_t i=0; i < _count; i++) {
diff --git a/vespamalloc/src/vespamalloc/malloc/mallocdst.h b/vespamalloc/src/vespamalloc/malloc/mallocdst.h
index c1fe9b4528a..92a37997292 100644
--- a/vespamalloc/src/vespamalloc/malloc/mallocdst.h
+++ b/vespamalloc/src/vespamalloc/malloc/mallocdst.h
@@ -10,7 +10,7 @@ typedef ThreadListT<MemBlockBoundsCheck, Stat> ThreadList;
 typedef MemoryWatcher<MemBlockBoundsCheck, ThreadList> Allocator;
 
 static char _Gmem[sizeof(Allocator)];
-static Allocator *_GmemP = NULL;
+static Allocator *_GmemP = nullptr;
 
 template <size_t MaxSizeClassMultiAllocC, size_t StackTraceLen>
 void MemBlockBoundsCheckBaseT<MaxSizeClassMultiAllocC, StackTraceLen>::dumpInfo(size_t level)
diff --git a/vespamalloc/src/vespamalloc/malloc/memblock.h b/vespamalloc/src/vespamalloc/malloc/memblock.h
index e8d8e274678..3f55e33b23e 100644
--- a/vespamalloc/src/vespamalloc/malloc/memblock.h
+++ b/vespamalloc/src/vespamalloc/malloc/memblock.h
@@ -31,11 +31,11 @@ public:
     void setExact(size_t)     { }
     void setExact(size_t, std::align_val_t )    { }
     void alloc(bool )         { }
-    void setThreadId(int )    { }
+    void setThreadId(uint32_t ) { }
     void free()               { }
     size_t size()       const { return 0; }
     bool allocated()    const { return false; }
-    int threadId()      const { return 0; }
+    uint32_t threadId()      const { return 0; }
     void info(FILE *, unsigned level=0) const  { (void) level; }
     Stack * callStack()                   { return nullptr; }
     size_t callStackLen()           const { return 0; }
diff --git a/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.h b/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.h
index 1860f2f36d3..90445666063 100644
--- a/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.h
+++ b/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.h
@@ -20,11 +20,11 @@ public:
         return p ? (p+alignment()) : nullptr;
     }
 
-    void setThreadId(int th)              { if (_ptr) { static_cast<uint32_t*>(_ptr)[2] = th; } }
+    void setThreadId(uint32_t th)         { if (_ptr) { static_cast<uint32_t *>(_ptr)[2] = th; } }
     bool allocated()                const { return (static_cast<uint32_t*>(_ptr)[3] == ALLOC_MAGIC); }
     size_t size()                   const { return static_cast<const uint32_t *>(_ptr)[0]; }
     size_t alignment()              const { return static_cast<const uint32_t *>(_ptr)[1]; }
-    int threadId()                  const { return static_cast<int*>(_ptr)[2]; }
+    uint32_t threadId()                  const { return static_cast<uint32_t *>(_ptr)[2]; }
     Stack * callStack()                   { return reinterpret_cast<Stack *>((char *)_ptr + size() + alignment()); }
     const Stack * callStack()       const { return reinterpret_cast<const Stack *>((const char *)_ptr + size() + alignment()); }
     void fillMemory(size_t sz) {
diff --git a/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.hpp b/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.hpp
index cac24a12714..d4890fac187 100644
--- a/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.hpp
+++ b/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.hpp
@@ -10,7 +10,7 @@ void MemBlockBoundsCheckBaseT<MaxSizeClassMultiAllocC, StackTraceLen>::info(FILE
 {
     if (validCommon()) {
         if (level & 0x02) {
-            fprintf(os, "{ %8p(%ld, %d) ", ptr(), size(), threadId());
+            fprintf(os, "{ %8p(%ld, %u) ", ptr(), size(), threadId());
             const Stack * cStack = callStack();
             for (int i=0; i<int(StackTraceLen);i++) {
                 if (cStack[i].valid()) {
@@ -21,7 +21,7 @@ void MemBlockBoundsCheckBaseT<MaxSizeClassMultiAllocC, StackTraceLen>::info(FILE
             fprintf(os, " }");
         }
         if (level & 0x01) {
-            fprintf(os, " %8p(%ld, %d)", ptr(), size(), threadId());
+            fprintf(os, " %8p(%ld, %u)", ptr(), size(), threadId());
         }
         if (level == 0) {
             fprintf(os, " %8p(%ld)", ptr(), size());
diff --git a/vespamalloc/src/vespamalloc/malloc/threadlist.h b/vespamalloc/src/vespamalloc/malloc/threadlist.h
index 149396a3bff..95ff072d035 100644
--- a/vespamalloc/src/vespamalloc/malloc/threadlist.h
+++ b/vespamalloc/src/vespamalloc/malloc/threadlist.h
@@ -27,22 +27,17 @@ public:
     ThreadPool & getCurrent()  { return *_myPool; }
     size_t getThreadId() const { return (_myPool - _threadVector); }
     void enableThreadSupport() {
-        if ( ! _isThreaded ) {
-            _isThreaded = true;
-        }
+        _isThreaded.test_and_set();
     }
 
     void info(FILE * os, size_t level=0);
     size_t getMaxNumThreads() const { return NELEMS(_threadVector); }
 private:
-    size_t getThreadCount()        const { return _threadCount; }
-    size_t getThreadCountAccum()   const { return _threadCountAccum; }
     ThreadListT(const ThreadListT & tl);
     ThreadListT & operator = (const ThreadListT & tl);
-    enum {ThreadStackSize=2048*1024};
-    volatile bool              _isThreaded;
-    std::atomic<size_t>        _threadCount;
-    std::atomic<size_t>        _threadCountAccum;
+    std::atomic_flag           _isThreaded;
+    std::atomic<uint32_t>      _threadCount;
+    std::atomic<uint32_t>      _threadCountAccum;
     ThreadPool                 _threadVector[NUM_THREADS];
     AllocPoolT<MemBlockPtrT> & _allocPool;
     static thread_local ThreadPool * _myPool TLS_LINKAGE;
diff --git a/vespamalloc/src/vespamalloc/malloc/threadlist.hpp b/vespamalloc/src/vespamalloc/malloc/threadlist.hpp
index e437981febc..a9a3a351899 100644
--- a/vespamalloc/src/vespamalloc/malloc/threadlist.hpp
+++ b/vespamalloc/src/vespamalloc/malloc/threadlist.hpp
@@ -18,9 +18,7 @@ ThreadListT<MemBlockPtrT, ThreadStatT>::ThreadListT(AllocPool & pool) :
 }
 
 template <typename MemBlockPtrT, typename ThreadStatT>
-ThreadListT<MemBlockPtrT, ThreadStatT>::~ThreadListT()
-{
-}
+ThreadListT<MemBlockPtrT, ThreadStatT>::~ThreadListT() = default;
 
 template <typename MemBlockPtrT, typename ThreadStatT>
 void ThreadListT<MemBlockPtrT, ThreadStatT>::info(FILE * os, size_t level)
@@ -57,7 +55,7 @@ bool ThreadListT<MemBlockPtrT, ThreadStatT>::initThisThread()
 {
     bool retval(true);
     _threadCount.fetch_add(1);
-    size_t lidAccum = _threadCountAccum.fetch_add(1);
+    uint32_t lidAccum = _threadCountAccum.fetch_add(1);
     long localId(-1);
     for(size_t i = 0; (localId < 0) && (i < getMaxNumThreads()); i++) {
         ThreadPool & tp = _threadVector[i];
@@ -66,10 +64,11 @@ bool ThreadListT<MemBlockPtrT, ThreadStatT>::initThisThread()
         }
     }
     assert(localId >= 0);
+    assert(size_t(localId) < getMaxNumThreads());
     _myPool = &_threadVector[localId];
     assert(getThreadId() == size_t(localId));
-
-    getCurrent().init(lidAccum);
+    assert(lidAccum < 0xffffffffu);
+    getCurrent().init(lidAccum+1);
 
     return retval;
 }
diff --git a/vespamalloc/src/vespamalloc/malloc/threadpool.h b/vespamalloc/src/vespamalloc/malloc/threadpool.h
index 1c3bb8f84c1..4b3483c45bc 100644
--- a/vespamalloc/src/vespamalloc/malloc/threadpool.h
+++ b/vespamalloc/src/vespamalloc/malloc/threadpool.h
@@ -42,17 +42,17 @@ private:
     bool hasActuallyBeenUsed() const;
     ThreadPoolT(const ThreadPoolT & rhs);
     ThreadPoolT & operator =(const ThreadPoolT & rhs);
-    unsigned threadId()    const { return _threadId; }
-    void setThreadId(unsigned th)   { _threadId = th; }
+    uint32_t threadId()    const { return _threadId; }
+    void setThreadId(uint32_t th)   { _threadId = th; }
     class AllocFree {
     public:
-        AllocFree() : _allocFrom(NULL), _freeTo(NULL) { }
+        AllocFree() : _allocFrom(nullptr), _freeTo(nullptr) { }
         void init(AllocPool & allocPool, SizeClassT sc) {
-            if (_allocFrom == NULL) {
+            if (_allocFrom == nullptr) {
                 _allocFrom = allocPool.getFree(sc, 1);
-                assert(_allocFrom != NULL);
+                assert(_allocFrom != nullptr);
                 _freeTo = allocPool.getFree(sc, 1);
-                assert(_freeTo != NULL);
+                assert(_freeTo != nullptr);
             }
         }
         void swap() {
@@ -67,7 +67,7 @@ private:
     AllocPool   * _allocPool;
     AllocFree     _memList[NUM_SIZE_CLASSES];
     ThreadStatT   _stat[NUM_SIZE_CLASSES];
-    unsigned      _threadId;
+    uint32_t      _threadId;
     std::atomic<ssize_t> _osThreadId;
     static SizeClassT _alwaysReuseSCLimit __attribute__((visibility("hidden")));
     static size_t     _threadCacheLimit __attribute__((visibility("hidden")));
diff --git a/vespamalloc/src/vespamalloc/malloc/threadpool.hpp b/vespamalloc/src/vespamalloc/malloc/threadpool.hpp
index cb44f74ee63..2d3c020578b 100644
--- a/vespamalloc/src/vespamalloc/malloc/threadpool.hpp
+++ b/vespamalloc/src/vespamalloc/malloc/threadpool.hpp
@@ -86,7 +86,7 @@ mallocHelper(size_t exactSize,
 
 template <typename MemBlockPtrT, typename ThreadStatT >
 ThreadPoolT<MemBlockPtrT, ThreadStatT>::ThreadPoolT() :
-    _allocPool(NULL),
+    _allocPool(nullptr),
     _threadId(0),
     _osThreadId(0)
 {
@@ -170,7 +170,7 @@ bool ThreadPoolT<MemBlockPtrT, ThreadStatT>::hasActuallyBeenUsed() const
 {
     bool used(false);
     for (size_t i=0; !used && (i < NELEMS(_memList)); i++) {
-        used = (_memList[i]._allocFrom != NULL
+        used = (_memList[i]._allocFrom != nullptr
                 && !_memList[i]._allocFrom->empty()
                 && !_memList[i]._freeTo->full());
     }