From d6d03eff698a549ef46372e5b8e07be2be84d448 Mon Sep 17 00:00:00 2001 From: Henning Baldersheim Date: Tue, 29 Jun 2021 10:36:09 +0000 Subject: GC unused atdoubledelete_loglevel --- vespamalloc/src/vespamalloc/malloc/malloc.h | 5 +---- vespamalloc/src/vespamalloc/malloc/memorywatcher.h | 5 +---- 2 files changed, 2 insertions(+), 8 deletions(-) (limited to 'vespamalloc/src') diff --git a/vespamalloc/src/vespamalloc/malloc/malloc.h b/vespamalloc/src/vespamalloc/malloc/malloc.h index 51efe28eafc..5ea71d9ea47 100644 --- a/vespamalloc/src/vespamalloc/malloc/malloc.h +++ b/vespamalloc/src/vespamalloc/malloc/malloc.h @@ -61,8 +61,7 @@ public: { _segment.setupLog(noMemLogLevel, bigMemLogLevel, bigLimit, bigIncrement, allocs2Show); } - void setupLog(size_t doubleDelete, size_t invalidMem, size_t prAllocLimit) { - _doubleDeleteLogLevel = doubleDelete; + void setupLog(size_t invalidMem, size_t prAllocLimit) { _invalidMemLogLevel = invalidMem; _prAllocLimit = prAllocLimit; } @@ -76,7 +75,6 @@ private: void crash() __attribute__((noinline));; typedef AllocPoolT AllocPool; typedef typename ThreadListT::ThreadPool ThreadPool; - size_t _doubleDeleteLogLevel; size_t _invalidMemLogLevel; size_t _prAllocLimit; DataSegment _segment; @@ -87,7 +85,6 @@ private: template MemoryManager::MemoryManager(size_t logLimitAtStart) : IAllocator(), - _doubleDeleteLogLevel(1), _invalidMemLogLevel(1), _prAllocLimit(logLimitAtStart), _segment(), diff --git a/vespamalloc/src/vespamalloc/malloc/memorywatcher.h b/vespamalloc/src/vespamalloc/malloc/memorywatcher.h index 2bb38541314..b992f4b264f 100644 --- a/vespamalloc/src/vespamalloc/malloc/memorywatcher.h +++ b/vespamalloc/src/vespamalloc/malloc/memorywatcher.h @@ -61,7 +61,6 @@ private: atend_loglevel, pralloc_loglimit, atnomem_loglevel, - atdoubledelete_loglevel, atinvalid_loglevel, bigsegment_loglevel, bigsegment_limit, @@ -126,7 +125,6 @@ MemoryWatcher::Params::Params() _params[ atend_loglevel] = NameValuePair("atend_loglevel", "1"); _params[ pralloc_loglimit] = NameValuePair("pralloc_loglimit", "0x2000000"); _params[ atnomem_loglevel] = NameValuePair("atnomem_loglevel", "1"); - _params[atdoubledelete_loglevel] = NameValuePair("atdoubledelete_loglevel", "1"); _params[ atinvalid_loglevel] = NameValuePair("atinvalid_loglevel", "1"); _params[ bigsegment_loglevel] = NameValuePair("bigsegment_loglevel", "1"); _params[ bigsegment_limit] = NameValuePair("bigsegment_limit", "0x1000000000"); // 64GM @@ -212,8 +210,7 @@ void MemoryWatcher::activateOptions() _params[Params::bigsegment_limit].valueAsLong(), _params[Params::bigsegment_increment].valueAsLong(), _params[Params::allocs2show].valueAsLong()); - this->setupLog(_params[Params::atdoubledelete_loglevel].valueAsLong(), - _params[Params::atinvalid_loglevel].valueAsLong(), + this->setupLog(_params[Params::atinvalid_loglevel].valueAsLong(), _params[Params::pralloc_loglimit].valueAsLong()); this->setParams(_params[Params::alwaysreuselimit].valueAsLong(), _params[Params::threadcachelimit].valueAsLong()); -- cgit v1.2.3 From b2bcbb4807896b14ef34a41efa2054cc2a90a9ab Mon Sep 17 00:00:00 2001 From: Henning Baldersheim Date: Tue, 29 Jun 2021 10:47:39 +0000 Subject: GC atnomem_loglevel and atinvalid_loglevel --- vespamalloc/etc/vespamalloc.conf | 2 -- vespamalloc/src/vespamalloc/malloc/datasegment.h | 6 +--- vespamalloc/src/vespamalloc/malloc/datasegment.hpp | 3 -- vespamalloc/src/vespamalloc/malloc/malloc.h | 13 ++------ vespamalloc/src/vespamalloc/malloc/memorywatcher.h | 38 +++++++++------------- 5 files changed, 20 insertions(+), 42 deletions(-) (limited to 'vespamalloc/src') diff --git a/vespamalloc/etc/vespamalloc.conf b/vespamalloc/etc/vespamalloc.conf index c7b20a170b5..c2b79061ea5 100644 --- a/vespamalloc/etc/vespamalloc.conf +++ b/vespamalloc/etc/vespamalloc.conf @@ -24,6 +24,4 @@ bigblocklimit 0x80000000 # default(0x800000) Limit for when to log ne pralloc_loglimit 0x7fffffffffffffff # What to log pr alloc. default(0x7fffffffffffffff) except mallocdst(0x200000). mallocdst_nl(0x7fffffffffffffff), but has effect on SIGHUP. #Some deprecated/less usefull ones. -atnomem_loglevel 2 # default(1) Loglevel used when datasegment is exhausted. -atinvalid_loglevel 2 # default(1) Loglevel used when vespa_malloc discovers logical error. allocs2show 0 # Number of allocations to show when dumping stacktrace. diff --git a/vespamalloc/src/vespamalloc/malloc/datasegment.h b/vespamalloc/src/vespamalloc/malloc/datasegment.h index 5c1c1f06088..3bd87ca343f 100644 --- a/vespamalloc/src/vespamalloc/malloc/datasegment.h +++ b/vespamalloc/src/vespamalloc/malloc/datasegment.h @@ -30,11 +30,8 @@ public: size_t textSize() const { return size_t(start()); } size_t infoThread(FILE * os, int level, uint32_t thread, SizeClassT sct, uint32_t maxThreadId=0) 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, - size_t allocs2Show) + void setupLog(size_t bigMemLogLevel, size_t bigLimit, size_t bigIncrement, size_t allocs2Show) { - _noMemLogLevel = noMemLogLevel; _bigSegmentLogLevel = bigMemLogLevel; if ((size_t(end()) < _nextLogLimit) || (size_t(end()) < (size_t(start()) + bigLimit))) { _nextLogLimit = size_t(start()) + bigLimit; @@ -114,7 +111,6 @@ private: typedef BlockT BlockList[BlockCount]; typedef FreeListT FreeList; OSMemory _osMemory; - size_t _noMemLogLevel; size_t _bigSegmentLogLevel; size_t _bigIncrement; size_t _allocs2Show; diff --git a/vespamalloc/src/vespamalloc/malloc/datasegment.hpp b/vespamalloc/src/vespamalloc/malloc/datasegment.hpp index 355c9e9daad..3fb56c6feb3 100644 --- a/vespamalloc/src/vespamalloc/malloc/datasegment.hpp +++ b/vespamalloc/src/vespamalloc/malloc/datasegment.hpp @@ -13,7 +13,6 @@ DataSegment::~DataSegment() = default; template DataSegment::DataSegment() : _osMemory(BlockSize), - _noMemLogLevel(1), _bigSegmentLogLevel(0), _bigIncrement (0x4000000), _allocs2Show (8), @@ -98,8 +97,6 @@ void * DataSegment::getBlock(size_t & oldBlockSize, SizeClassT sc) if (recurse++ == 0) { perror("Failed extending datasegment: "); assert(false); - MemBlockPtrT::dumpInfo(_noMemLogLevel); - sleep(2); } return nullptr; } diff --git a/vespamalloc/src/vespamalloc/malloc/malloc.h b/vespamalloc/src/vespamalloc/malloc/malloc.h index 5ea71d9ea47..e6330e7e55f 100644 --- a/vespamalloc/src/vespamalloc/malloc/malloc.h +++ b/vespamalloc/src/vespamalloc/malloc/malloc.h @@ -53,16 +53,11 @@ public: void info(FILE * os, size_t level=0) __attribute__ ((noinline)); - void setupSegmentLog(size_t noMemLogLevel, - size_t bigMemLogLevel, - size_t bigLimit, - size_t bigIncrement, - size_t allocs2Show) + void setupSegmentLog(size_t bigMemLogLevel, size_t bigLimit, size_t bigIncrement, size_t allocs2Show) { - _segment.setupLog(noMemLogLevel, bigMemLogLevel, bigLimit, bigIncrement, allocs2Show); + _segment.setupLog(bigMemLogLevel, bigLimit, bigIncrement, allocs2Show); } - void setupLog(size_t invalidMem, size_t prAllocLimit) { - _invalidMemLogLevel = invalidMem; + void setupLog(size_t prAllocLimit) { _prAllocLimit = prAllocLimit; } void setParams(size_t alwayReuseLimit, size_t threadCacheLimit) { @@ -75,7 +70,6 @@ private: void crash() __attribute__((noinline));; typedef AllocPoolT AllocPool; typedef typename ThreadListT::ThreadPool ThreadPool; - size_t _invalidMemLogLevel; size_t _prAllocLimit; DataSegment _segment; AllocPool _allocPool; @@ -85,7 +79,6 @@ private: template MemoryManager::MemoryManager(size_t logLimitAtStart) : IAllocator(), - _invalidMemLogLevel(1), _prAllocLimit(logLimitAtStart), _segment(), _allocPool(_segment), diff --git a/vespamalloc/src/vespamalloc/malloc/memorywatcher.h b/vespamalloc/src/vespamalloc/malloc/memorywatcher.h index b992f4b264f..333291c5394 100644 --- a/vespamalloc/src/vespamalloc/malloc/memorywatcher.h +++ b/vespamalloc/src/vespamalloc/malloc/memorywatcher.h @@ -43,7 +43,7 @@ private: const char * valueName() const { return _valueName; } const char * value() const { return _value; } void value(const char * v) __attribute__((noinline)); - long valueAsLong() const __attribute__((noinline)) { return strtol(_value, NULL, 0); } + long valueAsLong() const __attribute__((noinline)) { return strtol(_value, nullptr, 0); } void info(FILE * os) __attribute__ ((noinline)) { fprintf(os, "%s = %s %ld", valueName(), value(), valueAsLong()); } @@ -60,8 +60,6 @@ private: sigprof_loglevel, atend_loglevel, pralloc_loglimit, - atnomem_loglevel, - atinvalid_loglevel, bigsegment_loglevel, bigsegment_limit, bigsegment_increment, @@ -124,8 +122,6 @@ MemoryWatcher::Params::Params() _params[ sigprof_loglevel] = NameValuePair("sigprof_loglevel", "1"); _params[ atend_loglevel] = NameValuePair("atend_loglevel", "1"); _params[ pralloc_loglimit] = NameValuePair("pralloc_loglimit", "0x2000000"); - _params[ atnomem_loglevel] = NameValuePair("atnomem_loglevel", "1"); - _params[ atinvalid_loglevel] = NameValuePair("atinvalid_loglevel", "1"); _params[ bigsegment_loglevel] = NameValuePair("bigsegment_loglevel", "1"); _params[ bigsegment_limit] = NameValuePair("bigsegment_limit", "0x1000000000"); // 64GM _params[ bigsegment_increment] = NameValuePair("bigsegment_increment", "0x100000000"); //4GM @@ -197,7 +193,7 @@ bool MemoryWatcher::activateLogFile(const char *logfile) if ((oldFp != stderr) && (oldFp != stdout)) { fclose(oldFp); } - return (_logFile != NULL); + return (_logFile != nullptr); } template @@ -205,13 +201,11 @@ void MemoryWatcher::activateOptions() { activateLogFile(_params[Params::logfile].value()); T::dumpFile(_logFile); - this->setupSegmentLog(_params[Params::atnomem_loglevel].valueAsLong(), - _params[Params::bigsegment_loglevel].valueAsLong(), - _params[Params::bigsegment_limit].valueAsLong(), - _params[Params::bigsegment_increment].valueAsLong(), - _params[Params::allocs2show].valueAsLong()); - this->setupLog(_params[Params::atinvalid_loglevel].valueAsLong(), - _params[Params::pralloc_loglimit].valueAsLong()); + this->setupSegmentLog(_params[Params::bigsegment_loglevel].valueAsLong(), + _params[Params::bigsegment_limit].valueAsLong(), + _params[Params::bigsegment_increment].valueAsLong(), + _params[Params::allocs2show].valueAsLong()); + this->setupLog(_params[Params::pralloc_loglimit].valueAsLong()); this->setParams(_params[Params::alwaysreuselimit].valueAsLong(), _params[Params::threadcachelimit].valueAsLong()); T::bigBlockLimit(_params[Params::bigblocklimit].valueAsLong()); @@ -226,7 +220,7 @@ const char *vespaHomeConf(char pathName[]) const char *home = "/opt/vespa"; const char *conf = "/etc/vespamalloc.conf"; const char *env = getenv("VESPA_HOME"); - if (env != NULL) { + if (env != nullptr) { home = env; } if ((strlen(home) + strlen(conf)) >= PATH_MAX) { @@ -276,21 +270,21 @@ void MemoryWatcher::parseOptions(char * options) { bool isComment(false); const char ignore('\0'); - const char *valueName(NULL); - const char *value(NULL); + const char *valueName(nullptr); + const char *value(nullptr); bool isWhite(true); for(char *p=options; *p; p++) { char c(*p); if (c == '\n') { - if ((valueName != NULL) && (value != NULL)) { + if ((valueName != nullptr) && (value != nullptr)) { if (_params.update(valueName, value) == false) { fprintf(stderr, "Invalid parameter %s", valueName); } } isComment = false; isWhite = true; - valueName = NULL; - value = NULL; + valueName = nullptr; + value = nullptr; } else if (isComment) { *p = ignore; } else if (c == '#') { @@ -299,7 +293,7 @@ void MemoryWatcher::parseOptions(char * options) } else { if (isWhite) { if (!isspace(c)) { - if (valueName == NULL) { + if (valueName == nullptr) { valueName = p; } else { value = p; @@ -344,7 +338,7 @@ void MemoryWatcher::signalHandler(int signum, siginfo_t * sig, void * arg if (_params[Params::sigprof_loglevel].valueAsLong() > 1) { fprintf(_logFile, "SignalHandler %d done\n", signum); } - if ((_oldSig.sa_handler != SIG_IGN) && (_oldSig.sa_handler != SIG_DFL) && (_oldSig.sa_handler != NULL)) { + if ((_oldSig.sa_handler != SIG_IGN) && (_oldSig.sa_handler != SIG_DFL) && (_oldSig.sa_handler != nullptr)) { (_oldSig.sa_sigaction)(signum, sig, arg); } } @@ -374,7 +368,7 @@ bool MemoryWatcher::signal(int signum) } template -MemoryWatcher * MemoryWatcher::_manager = NULL; +MemoryWatcher * MemoryWatcher::_manager = nullptr; } // namespace vespamalloc -- cgit v1.2.3 From bb00676ae9d58e54e7079a7844250d50bd350682 Mon Sep 17 00:00:00 2001 From: Henning Baldersheim Date: Tue, 29 Jun 2021 11:41:10 +0000 Subject: Remove support for configuring always-reuse-limit. It has never been used in 16 years... --- vespamalloc/etc/vespamalloc.conf | 1 - vespamalloc/src/vespamalloc/malloc/common.h | 18 +++---- vespamalloc/src/vespamalloc/malloc/globalpool.h | 7 +-- vespamalloc/src/vespamalloc/malloc/globalpool.hpp | 60 +++++++++------------- vespamalloc/src/vespamalloc/malloc/malloc.h | 9 ++-- vespamalloc/src/vespamalloc/malloc/memorywatcher.h | 11 +--- vespamalloc/src/vespamalloc/malloc/threadlist.h | 4 +- vespamalloc/src/vespamalloc/malloc/threadpool.h | 7 +-- vespamalloc/src/vespamalloc/malloc/threadpool.hpp | 6 +-- 9 files changed, 49 insertions(+), 74 deletions(-) (limited to 'vespamalloc/src') diff --git a/vespamalloc/etc/vespamalloc.conf b/vespamalloc/etc/vespamalloc.conf index c2b79061ea5..3ece047ae07 100644 --- a/vespamalloc/etc/vespamalloc.conf +++ b/vespamalloc/etc/vespamalloc.conf @@ -3,7 +3,6 @@ logfile stderr # default(stderr) This is the file to where log is written (stderr, stdout, filename) # Tuning. But default is probably good. -alwaysreuselimit 0x200000 # default(0x200000) Objects larger than this will always be returned to the segment for reuse, also by other size classes.. threadcachelimit 0x10000 # default(0x10000) Max bytes in thread local cache per size class. fillvalue 0xa8 # default(0xa8) means not used. libvespamalloc(dXXXX).so have the possibility to fill memory on free and verify on malloc. This is to help catch use after free errors. diff --git a/vespamalloc/src/vespamalloc/malloc/common.h b/vespamalloc/src/vespamalloc/malloc/common.h index b1b26f6b350..2bb7df58957 100644 --- a/vespamalloc/src/vespamalloc/malloc/common.h +++ b/vespamalloc/src/vespamalloc/malloc/common.h @@ -52,15 +52,13 @@ static constexpr uint32_t NUM_THREADS = 16384; #define PARANOID_CHECK3(a) #endif -typedef MmapMemory OSMemory; - -typedef int SizeClassT; +using OSMemory = MmapMemory; +using SizeClassT = int; +constexpr size_t ALWAYS_REUSE_LIMIT = 0x200000ul; -inline int msbIdx(uint64_t v) { - int64_t result; - __asm __volatile("bsrq %0,%0" : "=r" (result) : "0" (v)); - return result; +inline constexpr int msbIdx(uint64_t v) { + return (sizeof(v)*8 - 1) - __builtin_clzl(v); } template @@ -69,14 +67,14 @@ class CommonT public: static constexpr size_t MAX_ALIGN = 0x200000ul; enum {MinClassSize = MinClassSizeC}; - static inline SizeClassT sizeClass(size_t sz) { + static inline constexpr SizeClassT sizeClass(size_t sz) { SizeClassT tmp(msbIdx(sz - 1) - (MinClassSizeC - 1)); return (sz <= (1 << MinClassSizeC )) ? 0 : tmp; } - static inline size_t classSize(SizeClassT sc) { return (size_t(1) << (sc + MinClassSizeC)); } + static inline constexpr size_t classSize(SizeClassT sc) { return (size_t(1) << (sc + MinClassSizeC)); } }; -inline void crash() { *((volatile unsigned *) NULL) = 0; } +inline void crash() { *((volatile unsigned *) nullptr) = 0; } template inline void swap(T & a, T & b) { T tmp(a); a = b; b = tmp; } diff --git a/vespamalloc/src/vespamalloc/malloc/globalpool.h b/vespamalloc/src/vespamalloc/malloc/globalpool.h index 872fd9b936e..98f19efae31 100644 --- a/vespamalloc/src/vespamalloc/malloc/globalpool.h +++ b/vespamalloc/src/vespamalloc/malloc/globalpool.h @@ -27,8 +27,10 @@ public: DataSegment & dataSegment() { return _dataSegment; } void enableThreadSupport() __attribute__((noinline)); - static void setParams(size_t alwaysReuseLimit, size_t threadCacheLimit); - static size_t computeExactSize(size_t sz); + static void setParams(size_t threadCacheLimit); + static size_t computeExactSize(size_t sz) { + return (((sz + (ALWAYS_REUSE_LIMIT - 1)) / ALWAYS_REUSE_LIMIT) * ALWAYS_REUSE_LIMIT); + } void info(FILE * os, size_t level=0) __attribute__((noinline)); private: @@ -78,7 +80,6 @@ private: std::atomic _allocChunkList; Stat _stat[NUM_SIZE_CLASSES]; static size_t _threadCacheLimit __attribute__((visibility("hidden"))); - static size_t _alwaysReuseLimit __attribute__((visibility("hidden"))); }; } diff --git a/vespamalloc/src/vespamalloc/malloc/globalpool.hpp b/vespamalloc/src/vespamalloc/malloc/globalpool.hpp index 69f2a2cf820..cd0546933ae 100644 --- a/vespamalloc/src/vespamalloc/malloc/globalpool.hpp +++ b/vespamalloc/src/vespamalloc/malloc/globalpool.hpp @@ -9,12 +9,10 @@ namespace vespamalloc { template size_t AllocPoolT::_threadCacheLimit __attribute__((visibility("hidden"))) = 0x10000; -template -size_t AllocPoolT::_alwaysReuseLimit __attribute__((visibility("hidden"))) = 0x200000; template AllocPoolT::AllocPoolT(DataSegment & ds) - : _chunkPool(NULL), + : _chunkPool(nullptr), _scList(), _dataSegment(ds), _getChunks(0), @@ -25,9 +23,7 @@ AllocPoolT::AllocPoolT(DataSegment & ds) } template -AllocPoolT::~AllocPoolT() -{ -} +AllocPoolT::~AllocPoolT() = default; template void AllocPoolT::enableThreadSupport() @@ -37,9 +33,8 @@ void AllocPoolT::enableThreadSupport() template void -AllocPoolT::setParams(size_t alwaysReuseLimit, size_t threadCacheLimit) +AllocPoolT::setParams(size_t threadCacheLimit) { - _alwaysReuseLimit = alwaysReuseLimit; _threadCacheLimit = threadCacheLimit; } @@ -48,16 +43,16 @@ typename AllocPoolT::ChunkSList * AllocPoolT::getFree(SizeClassT sc) { typename ChunkSList::AtomicHeadPtr & empty = _scList[sc]._empty; - ChunkSList * csl(NULL); - while ((csl = ChunkSList::linkOut(empty)) == NULL) { + ChunkSList * csl(nullptr); + while ((csl = ChunkSList::linkOut(empty)) == nullptr) { Guard sync(_mutex); - if (empty.load(std::memory_order_relaxed)._ptr == NULL) { + if (empty.load(std::memory_order_relaxed)._ptr == nullptr) { ChunkSList * ncsl(getChunks(sync, 1)); if (ncsl) { ChunkSList::linkInList(empty, ncsl); } else { - assert(ncsl != NULL); - return NULL; + assert(ncsl != nullptr); + return nullptr; } } } @@ -69,16 +64,16 @@ template typename AllocPoolT::ChunkSList * AllocPoolT::getAlloc(SizeClassT sc) { - ChunkSList * csl(NULL); + ChunkSList * csl(nullptr); typename ChunkSList::AtomicHeadPtr & full = _scList[sc]._full; - while ((csl = ChunkSList::linkOut(full)) == NULL) { + while ((csl = ChunkSList::linkOut(full)) == nullptr) { Guard sync(_mutex); - if (full.load(std::memory_order_relaxed)._ptr == NULL) { + if (full.load(std::memory_order_relaxed)._ptr == nullptr) { ChunkSList * ncsl(malloc(sync, sc)); if (ncsl) { ChunkSList::linkInList(full, ncsl); } else { - return NULL; + return nullptr; } } USE_STAT2(_stat[sc]._getAlloc.fetch_add(1, std::memory_order_relaxed)); @@ -121,12 +116,6 @@ AllocPoolT::exchangeAlloc(SizeClassT sc, typename AllocPoolT -size_t -AllocPoolT::computeExactSize(size_t sz) { - return (((sz + (_alwaysReuseLimit - 1)) / _alwaysReuseLimit) * _alwaysReuseLimit); -} - template typename AllocPoolT::ChunkSList * AllocPoolT::exactAlloc(size_t exactSize, SizeClassT sc, @@ -145,10 +134,9 @@ AllocPoolT::exactAlloc(size_t exactSize, SizeClassT sc, template typename AllocPoolT::ChunkSList * -AllocPoolT::returnMemory(SizeClassT sc, - typename AllocPoolT::ChunkSList * csl) +AllocPoolT::returnMemory(SizeClassT sc, typename AllocPoolT::ChunkSList * csl) { - ChunkSList * completelyEmpty(NULL); + ChunkSList * completelyEmpty(nullptr); #if 0 completelyEmpty = exchangeFree(sc, csl); #else @@ -174,15 +162,15 @@ AllocPoolT::malloc(const Guard & guard, SizeClassT sc) const size_t cs(MemBlockPtrT::classSize(sc)); size_t blockSize = cs * numBlocks; void * block = _dataSegment.getBlock(blockSize, sc); - ChunkSList * csl(NULL); - if (block != NULL) { + ChunkSList * csl(nullptr); + if (block != nullptr) { numBlocks = (blockSize + cs - 1)/cs; const size_t blocksPerChunk(std::max(1, std::min(int(ChunkSList::NumBlocks), int(_threadCacheLimit >> (MemBlockPtrT::MinClassSize + sc))))); const size_t numChunks = (numBlocks+(blocksPerChunk-1))/blocksPerChunk; csl = getChunks(guard, numChunks); - if (csl != NULL) { + if (csl != nullptr) { char *first = (char *) block; const size_t itemSize = cs; size_t numItems(0); @@ -216,9 +204,9 @@ AllocPoolT::getChunks(const Guard & guard, size_t numChunks) ChunkSList * prev(csl); bool enough(true); for (size_t i=0; enough && (i < numChunks); i++, csl = csl->getNext()) { - if (csl == NULL) { + if (csl == nullptr) { csl = allocChunkList(guard); - enough = (csl != NULL); + enough = (csl != nullptr); if (prev) { prev->setNext(csl); } else { @@ -230,9 +218,9 @@ AllocPoolT::getChunks(const Guard & guard, size_t numChunks) if (enough) { csl = _chunkPool; _chunkPool = prev->getNext(); - prev->setNext(NULL); + prev->setNext(nullptr); } else { - csl = NULL; + csl = nullptr; } USE_STAT2(_getChunks.fetch_add(1, std::memory_order_relaxed)); USE_STAT2(_getChunksSum.fetch_add(numChunks, std::memory_order_relaxed)); @@ -247,14 +235,14 @@ AllocPoolT::allocChunkList(const Guard & guard) (void) guard; size_t blockSize(sizeof(ChunkSList)*0x2000); void * block = _dataSegment.getBlock(blockSize, _dataSegment.SYSTEM_BLOCK); - ChunkSList * newList(NULL); - if (block != NULL) { + ChunkSList * newList(nullptr); + if (block != nullptr) { size_t chunksInBlock(blockSize/sizeof(ChunkSList)); newList = new (block) ChunkSList[chunksInBlock]; for (size_t j=0; j < (chunksInBlock-1); j++) { newList[j].setNext(newList+j+1); } - newList[chunksInBlock-1].setNext(NULL); + newList[chunksInBlock-1].setNext(nullptr); } USE_STAT2(_allocChunkList.fetch_add(1, std::memory_order_relaxed)); return newList; diff --git a/vespamalloc/src/vespamalloc/malloc/malloc.h b/vespamalloc/src/vespamalloc/malloc/malloc.h index e6330e7e55f..f9a749c006e 100644 --- a/vespamalloc/src/vespamalloc/malloc/malloc.h +++ b/vespamalloc/src/vespamalloc/malloc/malloc.h @@ -53,16 +53,15 @@ public: void info(FILE * os, size_t level=0) __attribute__ ((noinline)); - void setupSegmentLog(size_t bigMemLogLevel, size_t bigLimit, size_t bigIncrement, size_t allocs2Show) - { + void setupSegmentLog(size_t bigMemLogLevel, size_t bigLimit, size_t bigIncrement, size_t allocs2Show) { _segment.setupLog(bigMemLogLevel, bigLimit, bigIncrement, allocs2Show); } void setupLog(size_t prAllocLimit) { _prAllocLimit = prAllocLimit; } - void setParams(size_t alwayReuseLimit, size_t threadCacheLimit) { - _threadList.setParams(alwayReuseLimit, threadCacheLimit); - _allocPool.setParams(alwayReuseLimit, threadCacheLimit); + void setParams(size_t threadCacheLimit) { + _threadList.setParams(threadCacheLimit); + _allocPool.setParams(threadCacheLimit); } const DataSegment & dataSegment() const { return _segment; } private: diff --git a/vespamalloc/src/vespamalloc/malloc/memorywatcher.h b/vespamalloc/src/vespamalloc/malloc/memorywatcher.h index 333291c5394..b56200e2ab2 100644 --- a/vespamalloc/src/vespamalloc/malloc/memorywatcher.h +++ b/vespamalloc/src/vespamalloc/malloc/memorywatcher.h @@ -54,7 +54,6 @@ private: class Params { public: enum { - alwaysreuselimit = 0, threadcachelimit, logfile, sigprof_loglevel, @@ -106,8 +105,6 @@ private: NameValuePair _params[numberofentries]; }; FILE * _logFile; - int _infoAtAbort; - int _infoAtNOMEM; Params _params; struct sigaction _oldSig; @@ -116,7 +113,6 @@ private: template MemoryWatcher::Params::Params() { - _params[ alwaysreuselimit] = NameValuePair("alwaysreuselimit", "0x200000"); // 2M for allignment with hugepage size. _params[ threadcachelimit] = NameValuePair("threadcachelimit", "0x10000"); // 64K _params[ logfile] = NameValuePair("logfile", "stderr"); _params[ sigprof_loglevel] = NameValuePair("sigprof_loglevel", "1"); @@ -157,9 +153,7 @@ void MemoryWatcher::NameValuePair::value(const char * v) { template MemoryWatcher::MemoryWatcher(int infoAtEnd, size_t prAllocAtStart) : MemoryManager(prAllocAtStart), - _logFile(stderr), - _infoAtAbort(-1), - _infoAtNOMEM(1) + _logFile(stderr) { _manager = this; char tmp[16]; @@ -206,8 +200,7 @@ void MemoryWatcher::activateOptions() _params[Params::bigsegment_increment].valueAsLong(), _params[Params::allocs2show].valueAsLong()); this->setupLog(_params[Params::pralloc_loglimit].valueAsLong()); - this->setParams(_params[Params::alwaysreuselimit].valueAsLong(), - _params[Params::threadcachelimit].valueAsLong()); + this->setParams(_params[Params::threadcachelimit].valueAsLong()); T::bigBlockLimit(_params[Params::bigblocklimit].valueAsLong()); T::setFill(_params[Params::fillvalue].valueAsLong()); diff --git a/vespamalloc/src/vespamalloc/malloc/threadlist.h b/vespamalloc/src/vespamalloc/malloc/threadlist.h index 9edf086ca96..91409eb2c95 100644 --- a/vespamalloc/src/vespamalloc/malloc/threadlist.h +++ b/vespamalloc/src/vespamalloc/malloc/threadlist.h @@ -19,8 +19,8 @@ public: using AllocPool = AllocPoolT; ThreadListT(AllocPool & pool); ~ThreadListT(); - void setParams(size_t alwayReuseLimit, size_t threadCacheLimit) { - ThreadPool::setParams(alwayReuseLimit, threadCacheLimit); + void setParams(size_t threadCacheLimit) { + ThreadPool::setParams(threadCacheLimit); } bool quitThisThread(); bool initThisThread(); diff --git a/vespamalloc/src/vespamalloc/malloc/threadpool.h b/vespamalloc/src/vespamalloc/malloc/threadpool.h index d4a754532ff..493369a4441 100644 --- a/vespamalloc/src/vespamalloc/malloc/threadpool.h +++ b/vespamalloc/src/vespamalloc/malloc/threadpool.h @@ -37,7 +37,7 @@ public: uint32_t threadId() const { return _threadId; } void quit() { _osThreadId = 0; } // Implicit memory barrier void init(int thrId); - static void setParams(size_t alwayReuseLimit, size_t threadCacheLimit); + static void setParams(size_t threadCacheLimit); bool grabAvailable(); private: bool hasActuallyBeenUsed() const; @@ -62,7 +62,7 @@ private: ChunkSList *_freeTo; }; void mallocHelper(size_t exactSize, SizeClassT sc, AllocFree & af, MemBlockPtrT & mem) __attribute__ ((noinline)); - static bool alwaysReuse(SizeClassT sc) { return sc > _alwaysReuseSCLimit; } + static constexpr bool alwaysReuse(SizeClassT sc) { return sc > ALWAYS_REUSE_SC_LIMIT; } AllocPool * _allocPool; AllocFree _memList[NUM_SIZE_CLASSES]; @@ -70,7 +70,8 @@ private: uint32_t _threadId; std::atomic _osThreadId; - static SizeClassT _alwaysReuseSCLimit __attribute__((visibility("hidden"))); + static constexpr SizeClassT ALWAYS_REUSE_SC_LIMIT = std::max(MemBlockPtrT::sizeClass(ALWAYS_REUSE_LIMIT), + SizeClassT(MemBlockPtrT::SizeClassSpan)); static size_t _threadCacheLimit __attribute__((visibility("hidden"))); }; diff --git a/vespamalloc/src/vespamalloc/malloc/threadpool.hpp b/vespamalloc/src/vespamalloc/malloc/threadpool.hpp index b28aa144c34..b4ce1b6d6d0 100644 --- a/vespamalloc/src/vespamalloc/malloc/threadpool.hpp +++ b/vespamalloc/src/vespamalloc/malloc/threadpool.hpp @@ -5,8 +5,6 @@ namespace vespamalloc { -template -SizeClassT ThreadPoolT::_alwaysReuseSCLimit __attribute__((visibility("hidden"))) = MemBlockPtrT::sizeClass(0x200000); template size_t ThreadPoolT::_threadCacheLimit __attribute__((visibility("hidden"))) = 0x10000; @@ -188,10 +186,8 @@ void ThreadPoolT::init(int thrId) } template -void ThreadPoolT::setParams(size_t alwaysReuseLimit, size_t threadCacheLimit) +void ThreadPoolT::setParams(size_t threadCacheLimit) { - _alwaysReuseSCLimit = std::max(MemBlockPtrT::sizeClass(alwaysReuseLimit), - SizeClassT(MemBlockPtrT::SizeClassSpan)); _threadCacheLimit = threadCacheLimit; } -- cgit v1.2.3 From 2baf0e8d284b0bd187425913ec4c6f1be1511511 Mon Sep 17 00:00:00 2001 From: Harald Musum Date: Tue, 29 Jun 2021 16:06:31 +0200 Subject: Revert "Add support for mallinfo2 with glibc 2.33" --- .../src/vespa/searchcore/proton/server/proton.cpp | 8 ++--- vespamalloc/src/tests/stacktrace/stacktrace.cpp | 21 +++-------- vespamalloc/src/tests/test1/new_test.cpp | 22 ++++++------ vespamalloc/src/vespamalloc/malloc/overload.h | 42 +++------------------- 4 files changed, 23 insertions(+), 70 deletions(-) (limited to 'vespamalloc/src') diff --git a/searchcore/src/vespa/searchcore/proton/server/proton.cpp b/searchcore/src/vespa/searchcore/proton/server/proton.cpp index adae323c1d9..9c5438825b2 100644 --- a/searchcore/src/vespa/searchcore/proton/server/proton.cpp +++ b/searchcore/src/vespa/searchcore/proton/server/proton.cpp @@ -767,15 +767,15 @@ Proton::updateMetrics(const metrics::MetricLockGuard &) metrics.resourceUsage.openFileDescriptors.set(FastOS_File::count_open_files()); metrics.resourceUsage.feedingBlocked.set((usageFilter.acceptWriteOperation() ? 0.0 : 1.0)); #ifdef __linux__ +#pragma GCC diagnostic push #if __GLIBC_PREREQ(2, 33) - struct mallinfo2 mallocInfo = mallinfo2(); - metrics.resourceUsage.mallocArena.set(mallocInfo.arena); -#else +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#endif struct mallinfo mallocInfo = mallinfo(); +#pragma GCC diagnostic pop // Vespamalloc reports arena in 1M blocks as an 'int' is too small. // If we use something else than vespamalloc this must be changed. metrics.resourceUsage.mallocArena.set(uint64_t(mallocInfo.arena) * 1_Mi); -#endif #else metrics.resourceUsage.mallocArena.set(UINT64_C(0)); #endif diff --git a/vespamalloc/src/tests/stacktrace/stacktrace.cpp b/vespamalloc/src/tests/stacktrace/stacktrace.cpp index 37322994586..f30e3c20f55 100644 --- a/vespamalloc/src/tests/stacktrace/stacktrace.cpp +++ b/vespamalloc/src/tests/stacktrace/stacktrace.cpp @@ -17,22 +17,12 @@ void * run(void * arg) } void verify_that_vespamalloc_datasegment_size_exists() { -#if __GLIBC_PREREQ(2, 33) - struct mallinfo2 info = mallinfo2(); - printf("Malloc used %zdm of memory\n", info.arena); - assert(info.arena >= 10 * 0x100000ul); - assert(info.arena < 10000 * 0x100000ul); - assert(info.fordblks == 0); - assert(info.fsmblks == 0); - assert(info.hblkhd == 0); - assert(info.hblks == 0); - assert(info.keepcost == 0); - assert(info.ordblks == 0); - assert(info.smblks == 0); - assert(info.uordblks == 0); - assert(info.usmblks == 0); -#else +#pragma GCC diagnostic push +#if __GNUC_PREREQ(2, 33) +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#endif struct mallinfo info = mallinfo(); +#pragma GCC diagnostic push printf("Malloc used %dm of memory\n",info.arena); assert(info.arena >= 10); assert(info.arena < 10000); @@ -45,7 +35,6 @@ void verify_that_vespamalloc_datasegment_size_exists() { assert(info.smblks == 0); assert(info.uordblks == 0); assert(info.usmblks == 0); -#endif } int main(int argc, char *argv[]) diff --git a/vespamalloc/src/tests/test1/new_test.cpp b/vespamalloc/src/tests/test1/new_test.cpp index ac053323255..9c291b3842e 100644 --- a/vespamalloc/src/tests/test1/new_test.cpp +++ b/vespamalloc/src/tests/test1/new_test.cpp @@ -95,19 +95,17 @@ TEST("verify new with alignment = 64 with single element") { LOG(info, "&s=%p", s.get()); } -#if __GLIBC_PREREQ(2, 26) -TEST("verify realloarray") { - void *arr = calloc(5,5); - void *arr2 = reallocarray(arr, 800, 5); - EXPECT_NOT_EQUAL(arr, arr2); - EXPECT_NOT_EQUAL(nullptr, arr2); - EXPECT_NOT_EQUAL(ENOMEM, errno); - - void *arr3 = reallocarray(arr2, 1u << 33, 1u << 33); - EXPECT_EQUAL(nullptr, arr3); - EXPECT_EQUAL(ENOMEM, errno); +TEST("verify new with alignment = 64 with single element") { + struct alignas(64) S { + long a; + }; + static_assert(sizeof(S) == 64); + static_assert(alignof(S) == 64); + auto s = std::make_unique(); + verify_aligned(s.get()); + cmp(s.get(), &s->a); + LOG(info, "&s=%p", s.get()); } -#endif void verify_vespamalloc_usable_size() { struct AllocInfo { size_t requested; size_t usable;}; diff --git a/vespamalloc/src/vespamalloc/malloc/overload.h b/vespamalloc/src/vespamalloc/malloc/overload.h index 8815a11a84f..1ec37c37aa1 100644 --- a/vespamalloc/src/vespamalloc/malloc/overload.h +++ b/vespamalloc/src/vespamalloc/malloc/overload.h @@ -106,23 +106,6 @@ void operator delete[](void* ptr, std::size_t sz, std::align_val_t alignment) no extern "C" { -#if __GLIBC_PREREQ(2, 33) -struct mallinfo2 mallinfo2() __THROW __attribute__((visibility ("default"))); -struct mallinfo2 mallinfo2() __THROW { - struct mallinfo2 info; - info.arena = vespamalloc::_GmemP->dataSegment().dataSize(); - info.ordblks = 0; - info.smblks = 0; - info.hblks = 0; - info.hblkhd = 0; - info.usmblks = 0; - info.fsmblks = 0; - info.uordblks = 0; - info.fordblks = 0; - info.keepcost = 0; - return info; -} -#else struct mallinfo mallinfo() __THROW __attribute__((visibility ("default"))); struct mallinfo mallinfo() __THROW { struct mallinfo info; @@ -138,7 +121,6 @@ struct mallinfo mallinfo() __THROW { info.keepcost = 0; return info; } -#endif void * malloc(size_t sz) { return vespamalloc::createAllocator()->malloc(sz); @@ -154,17 +136,6 @@ void * realloc(void * ptr, size_t sz) return vespamalloc::createAllocator()->realloc(ptr, sz); } -void * reallocarray(void * ptr, size_t nemb, size_t elemSize) __THROW __attribute__((visibility ("default"))); -void * reallocarray(void * ptr, size_t nemb, size_t elemSize) __THROW -{ - size_t sz = nemb * elemSize; - if (nemb != 0 && (sz/nemb != elemSize)) { - errno = ENOMEM; - return nullptr; - } - return vespamalloc::createAllocator()->realloc(ptr, sz); -} - void* memalign(size_t align, size_t sz) __THROW __attribute__((visibility ("default"))); void* memalign(size_t align, size_t sz) __THROW { @@ -202,6 +173,7 @@ void *valloc(size_t size) __THROW return memalign(sysconf(_SC_PAGESIZE),size); } + void free(void * ptr) { if (ptr) { vespamalloc::_GmemP->free(ptr); } } @@ -215,8 +187,7 @@ size_t malloc_usable_size (void * ptr) __THROW { #ifdef __clang__ void* __libc_malloc(size_t sz) __THROW __attribute__((malloc, alloc_size(1))) ALIAS("malloc"); void* __libc_realloc(void* ptr, size_t sz) __THROW __attribute__((malloc, alloc_size(2))) ALIAS("realloc"); -void* __libc_reallocarray(void* ptr, size_t nemb, size_t sz) __THROW __attribute__((malloc, alloc_size(2,3))) ALIAS("reallocarray"); -void* __libc_calloc(size_t n, size_t sz) __THROW __attribute__((malloc, alloc_size(1,2))) ALIAS("calloc"); +void* __libc_calloc(size_t n, size_t sz) __THROW __attribute__((malloc, alloc_size(2))) ALIAS("calloc"); void cfree(void *) __THROW ALIAS("free"); void __libc_free(void* ptr) __THROW ALIAS("free"); #pragma clang diagnostic push @@ -226,20 +197,15 @@ void __libc_cfree(void* ptr) __THROW ALIAS("cfree"); #else void* __libc_malloc(size_t sz) __THROW __attribute__((leaf, malloc, alloc_size(1))) ALIAS("malloc"); void* __libc_realloc(void* ptr, size_t sz) __THROW __attribute__((leaf, malloc, alloc_size(2))) ALIAS("realloc"); -void* __libc_reallocarray(void* ptr, size_t nemb, size_t sz) __THROW __attribute__((leaf, malloc, alloc_size(2,3))) ALIAS("reallocarray"); -void* __libc_calloc(size_t n, size_t sz) __THROW __attribute__((leaf, malloc, alloc_size(1,2))) ALIAS("calloc"); +void* __libc_calloc(size_t n, size_t sz) __THROW __attribute__((leaf, malloc, alloc_size(2))) ALIAS("calloc"); void cfree(void *) __THROW __attribute__((leaf)) ALIAS("free"); void __libc_free(void* ptr) __THROW __attribute__((leaf)) ALIAS("free"); void __libc_cfree(void* ptr) __THROW __attribute__((leaf)) ALIAS("cfree"); #endif +struct mallinfo __libc_mallinfo() __THROW ALIAS("mallinfo"); size_t __libc_malloc_usable_size(void *ptr) __THROW ALIAS("malloc_usable_size"); void* __libc_memalign(size_t align, size_t s) __THROW __attribute__((leaf, malloc, alloc_size(2))) ALIAS("memalign"); int __posix_memalign(void** r, size_t a, size_t s) __THROW __nonnull((1)) ALIAS("posix_memalign"); -#if __GLIBC_PREREQ(2, 33) -struct mallinfo2 __libc_mallinfo2() __THROW ALIAS("mallinfo2"); -#else -struct mallinfo __libc_mallinfo() __THROW ALIAS("mallinfo"); -#endif #undef ALIAS } -- cgit v1.2.3