Update for V5.8

Author: knonomura

utility/Makefile.am

@@ -16,6 +16,8 @@ $(srcdir)/util/file.cpp \
 $(srcdir)/util/file.h \
 $(srcdir)/util/net.cpp \
 $(srcdir)/util/net.h \
+$(srcdir)/util/numeric.cpp \
+$(srcdir)/util/numeric.h \
 $(srcdir)/util/os.cpp \
 $(srcdir)/util/os.h \
 $(srcdir)/util/system.cpp \

utility/util/allocator.cpp

@@ -895,9 +895,12 @@ void FixedSizeCachedAllocator::setLimit(
 
 AllocatorLimitter* FixedSizeCachedAllocator::setLimit(
 		AllocatorStats::Type type, AllocatorLimitter *limitter, bool force) {
-	static_cast<void>(type);
-	static_cast<void>(limitter);
-	static_cast<void>(force);
+	if (localAlloc_.get() != NULL) {
+		localAlloc_->setLimit(type, limitter, force);
+	}
+	if (localLockedAlloc_.get() != NULL) {
+		localLockedAlloc_->setLimit(type, limitter, force);
+	}
 	return NULL;
 }
 
@@ -1419,8 +1422,6 @@ void* StackAllocator::allocateOverBlock(size_t size) {
 			hugeCount_++;
 			hugeSize_ += blockSize;
 
-			stats_.values_[AllocatorStats::STAT_TOTAL_SIZE] =
-					AllocatorStats::asStatValue(getTotalSizeForStats());
 			stats_.values_[AllocatorStats::STAT_PEAK_TOTAL_SIZE] = std::max(
 					stats_.values_[AllocatorStats::STAT_PEAK_TOTAL_SIZE],
 					stats_.values_[AllocatorStats::STAT_TOTAL_SIZE]);
@@ -1441,6 +1442,8 @@ void* StackAllocator::allocateOverBlock(size_t size) {
 	restSize_ = newBlock->bodySize() - size;
 
 	totalSize_ += newBlock->blockSize_;
+	stats_.values_[AllocatorStats::STAT_TOTAL_SIZE] =
+			AllocatorStats::asStatValue(getTotalSizeForStats());
 
 	return newBlock->body();
 #endif
@@ -1805,7 +1808,9 @@ void AllocatorManager::setSharingLimitterGroup(GroupId id, GroupId sharingId) {
 	assert(sharingEntry.totalLimitter_ != NULL);
 
 	entry.sharingLimitterId_ = sharingId;
-	entry.totalLimitter_ = sharingEntry.totalLimitter_;
+	setLimit(id, LIMIT_GROUP_TOTAL_SIZE, std::numeric_limits<size_t>::max());
+
+	assert(entry.totalLimitter_ != NULL);
 }
 
 int64_t AllocatorManager::estimateHeapUsage(
@@ -1869,7 +1874,7 @@ void AllocatorManager::applyAllocatorLimit(
 	switch (limitType) {
 	case LIMIT_GROUP_TOTAL_SIZE:
 		command = COMMAND_SET_TOTAL_LIMITTER;
-		type = AllocatorStats::STAT_TYPE_END;
+		type = AllocatorStats::STAT_GROUP_TOTAL_LIMIT;
 		if (groupEntry.totalLimitter_ == NULL) {
 			return;
 		}
@@ -2119,6 +2124,7 @@ AllocatorLimitter& AllocatorManager::prepareTotalLimitter(
 		else {
 			entry.totalLimitter_ =
 					&prepareTotalLimitter(entry.sharingLimitterId_, found);
+			found = false;
 		}
 	}
 	else {
@@ -2243,6 +2249,7 @@ AllocatorLimitter::AllocatorLimitter(
 		limit_(std::numeric_limits<size_t>::max()),
 		acquired_(0),
 		reserved_(0),
+		peakUsage_(0),
 		failOnExcess_(false),
 		errorHandler_(NULL) {
 }
@@ -2251,6 +2258,18 @@ AllocatorLimitter::~AllocatorLimitter() {
 	assert(acquired_ == 0);
 }
 
+AllocatorLimitter::Stats AllocatorLimitter::getStats() {
+	util::LockGuard<util::Mutex> guard(mutex_);
+
+	Stats stats;
+	stats.usage_ = getLocalUsageSize();
+	stats.peakUsage_ = peakUsage_;
+	stats.limit_ = limit_;
+	stats.failOnExcess_ = failOnExcess_;
+
+	return stats;
+}
+
 void AllocatorLimitter::setFailOnExcess(bool enabled) {
 	util::LockGuard<util::Mutex> guard(mutex_);
 	failOnExcess_ = enabled;
@@ -2278,6 +2297,7 @@ size_t AllocatorLimitter::acquire(
 	const size_t size =
 			acquireLocal(requestingMin, requestingDesired, force, requester);
 	reserved_ -= std::min(reserved_, size);
+	updatePeakUsageSize();
 	return size;
 }
 
@@ -2296,6 +2316,7 @@ void AllocatorLimitter::shrinkReservation(size_t size) {
 	const size_t actualSize = std::min(reserved_, size);
 	releaseLocal(actualSize);
 	reserved_ -= actualSize;
+	updatePeakUsageSize();
 }
 
 size_t AllocatorLimitter::getAvailableSize() {
@@ -2388,6 +2409,17 @@ size_t AllocatorLimitter::getLocalAvailableSize() {
 	return limit_ - acquired_;
 }
 
+size_t AllocatorLimitter::getLocalUsageSize() {
+	return acquired_ - reserved_;
+}
+
+void AllocatorLimitter::updatePeakUsageSize() {
+	const size_t current = getLocalUsageSize();
+	if (current > peakUsage_) {
+		peakUsage_ = current;
+	}
+}
+
 const AllocatorLimitter& AllocatorLimitter::resolveRequester(
 		const AllocatorLimitter *base) {
 	if (base == NULL) {
@@ -2447,4 +2479,11 @@ AllocatorLimitter::Scope::~Scope() {
 	unbinder_(allocator_, orgLimitter_);
 }
 
+AllocatorLimitter::Stats::Stats() :
+		usage_(0),
+		peakUsage_(0),
+		limit_(0),
+		failOnExcess_(false) {
+}
+
 }	

utility/util/allocator.h

@@ -2228,11 +2228,13 @@ static AllocatorManager::Initializer g_allocatorManagerInitializer;
 class AllocatorLimitter {
 public:
 	class Scope;
+	struct Stats;
 
 	AllocatorLimitter(const AllocatorInfo &info, AllocatorLimitter *parent);
 	~AllocatorLimitter();
 
-	size_t getLimit();
+	Stats getStats();
+
 	void setLimit(size_t size);
 	void setFailOnExcess(bool enabled);
 
@@ -2260,6 +2262,8 @@ class AllocatorLimitter {
 	void releaseLocal(size_t size);
 
 	size_t getLocalAvailableSize();
+	size_t getLocalUsageSize();
+	void updatePeakUsageSize();
 
 	const AllocatorLimitter& resolveRequester(const AllocatorLimitter *base);
 	bool resolveFailOnExcess(
@@ -2273,6 +2277,7 @@ class AllocatorLimitter {
 	size_t limit_;
 	size_t acquired_;
 	size_t reserved_;
+	size_t peakUsage_;
 	bool failOnExcess_;
 	util::Mutex mutex_;
 	util::AllocationErrorHandler *errorHandler_;
@@ -2295,6 +2300,15 @@ class AllocatorLimitter::Scope {
 	UnbindFunc unbinder_;
 };
 
+struct AllocatorLimitter::Stats {
+	Stats();
+
+	size_t usage_;
+	size_t peakUsage_;
+	size_t limit_;
+	bool failOnExcess_;
+};
+
 /*!
 	@brief STL string template for using allocators with members.
 */
@@ -3131,6 +3145,12 @@ inline void FixedSizeAllocator<Mutex>::acquireForRequester(
 	if (requester.acquire(elementSize_, limitter_)) {
 		assert(totalElementCount_ > 0);
 		totalElementCount_--;
+
+		int64_t &statValue = stats_.values_[AllocatorStats::STAT_TOTAL_SIZE];
+		const int64_t statSize = static_cast<int64_t>(elementSize_);
+
+		assert(statValue >= statSize);
+		statValue -= statSize;
 	}
 }
 
@@ -3140,6 +3160,11 @@ inline void FixedSizeAllocator<Mutex>::releaseForRequester(
 		const R &requester) {
 	if (requester.release(elementSize_, limitter_)) {
 		totalElementCount_++;
+
+		int64_t &statValue = stats_.values_[AllocatorStats::STAT_TOTAL_SIZE];
+		const int64_t statSize = static_cast<int64_t>(elementSize_);
+
+		statValue += statSize;
 	}
 }
 
@@ -3549,6 +3574,9 @@ AllocatorLimitter* VariableSizeAllocator<Mutex, Traits>::setLimit(
 	case AllocatorStats::STAT_GROUP_TOTAL_LIMIT:
 		limitter_ = AllocatorLimitter::moveSize(
 				limitter, limitter_, hugeElementSize_, force);
+		for (size_t i = 0; i < FIXED_ALLOCATOR_COUNT; i++) {
+			baseList_[i]->setLimit(type, limitter, force);
+		}
 		break;
 	default:
 		break;
@@ -4190,12 +4218,12 @@ inline void AllocatorManager::Accessor<Alloc>::access(
 		target->getStats(*params.stats_);
 		break;
 	case COMMAND_SET_TOTAL_LIMITTER:
-		target->setLimit(params.type_, params.size_);
-		break;
-	case COMMAND_SET_EACH_LIMIT:
 		assert(params.limitter_ != NULL);
 		target->setLimit(params.type_, params.limitter_);
 		break;
+	case COMMAND_SET_EACH_LIMIT:
+		target->setLimit(params.type_, params.size_);
+		break;
 #if UTIL_ALLOCATOR_DIFF_REPORTER_TRACE_ENABLED
 	case COMMAND_SAVE_REPORTER_SNAPSHOT: {
 		LockGuard<MutexType> guard(ManagerTool::getLock(*target));

utility/util/file.cpp

@@ -1566,13 +1566,13 @@ bool Directory::nextEntry(u8string &name) {
 	name.clear();
 
 #ifdef UTIL_HAVE_OPENDIR
-	DirEnt entryBuf;
 	struct dirent *result;
-	if (readdir_r(data_->dir_, &entryBuf.body_, &result) != 0) {
-		UTIL_THROW_PLATFORM_ERROR(NULL);
-	}
-
+	errno = 0;
+	result = readdir(data_->dir_);
 	if (result == NULL) {
+		if (errno != 0) {
+			UTIL_THROW_PLATFORM_ERROR(NULL);
+		}
 		return false;
 	}
 

utility/util/numeric.h

@@ -23,6 +23,7 @@
 
 #include "util/type.h"
 #include <limits>
+#include <climits>
 
 #if UTIL_CXX11_SUPPORTED
 #include <cmath>
@@ -34,11 +35,15 @@
 
 namespace util {
 
+
 template<typename T> bool isInf(const T &value);
 template<typename T> bool isFinite(const T &value);
 template<typename T> bool isNaN(const T &value);
 template<typename T> T copySign(const T &value1, const T &value2);
 
+/**
+ * 数値の算術演算ユーティリティ
+ */
 struct NumberArithmetic {
 public:
 	template<typename T, typename H> static T add(
@@ -193,6 +198,106 @@ struct ArithmeticErrorHandlers::Checked {
 	UtilityException::Code &errorCode_;
 };
 
+/**
+ * 固定長データ管理型の、double値(IEEE754の64ビット浮動小数点数)の合計値表現
+ *
+ * ほぼ任意回数(最大2^64回)のdouble値の加減算を繰り返しても、一切桁落ちしない。
+ * 無限大、NaNの追加回数を記憶できる。その回数分除外操作をすると、それらの
+ * 追加前のdouble値を参照できる。
+ */
+class FixedDoubleSum {
+public:
+
+	FixedDoubleSum();
+
+	void add(double value);
+
+	void remove(double value);
+
+	double get() const;
+
+private:
+	enum MergeMode {
+		MODE_ADD,
+		MODE_SUBTRACT_NORMAL,
+		MODE_SUBTRACT_REVERSED
+	};
+
+	enum {
+		UNIT_BIT = (sizeof(uint64_t) * CHAR_BIT),
+
+		MAX_EXPONENT = (std::numeric_limits<double>::max_exponent - 1),
+		MIN_EXPONENT = (std::numeric_limits<double>::min_exponent - 1),
+		EXPONENT_RANGE = (MAX_EXPONENT - MIN_EXPONENT + 1),
+
+		MANTISSA_IMPLICIT_BIT = 1,
+		MANTISSA_BIT = (
+				std::numeric_limits<double>::digits -
+				MANTISSA_IMPLICIT_BIT),
+		EXPONENT_BIT = (sizeof(double) * CHAR_BIT - MANTISSA_BIT - 1),
+
+		FINITE_VALUE_BIT = (
+				UNIT_BIT +
+				EXPONENT_RANGE +
+				MANTISSA_BIT),
+
+		FINITE_VALUE_SIZE = ((FINITE_VALUE_BIT + UNIT_BIT - 1) / UNIT_BIT)
+	};
+
+	typedef uint64_t FiniteValue[FINITE_VALUE_SIZE];
+	typedef std::pair<uint64_t, uint64_t> FiniteValuePart;
+
+	uint64_t& getSpecialValueCounter(double value);
+	bool findSpecialValue(double &value) const;
+
+	void addFiniteValue(double value);
+
+	MergeMode getMergeMode(
+			uint64_t mantissa, uint32_t exponent, bool sign,
+			bool &nextSign) const;
+	int32_t compareFiniteValue(uint64_t mantissa, uint32_t exponent) const;
+
+	static uint32_t getAmountPosition(
+			MergeMode mode, uint32_t exponent, bool lower);
+	static uint64_t getAmountPart(
+			uint64_t mantissa, uint32_t exponent, uint32_t unitPos);
+
+	static FiniteValuePart getFiniteValuePart(
+			const FiniteValue &finiteValue, uint32_t exponent);
+	static uint64_t mergeFiniteValuePart(
+			MergeMode mode, uint64_t target, uint64_t amount, bool lastCarry,
+			bool &nextCarry);
+	static uint64_t mergeFiniteValuePartWithLastCarry(
+			MergeMode mode, uint64_t target, uint64_t amount, bool &nextCarry);
+	static uint32_t resolveExponent(
+			const FiniteValue &finiteValue, uint32_t curPos, uint32_t lastExponent);
+
+	static void decomposeValue(
+			double value, uint64_t &mantissa, uint32_t &exponent);
+	static double makeFiniteValue(
+			const FiniteValuePart &valuePart, uint32_t exponent, bool sign);
+
+	static uint64_t valueToBits(double value);
+	static double bitsToValue(uint64_t bits);
+
+	static bool isSpecialValue(double value);
+	static bool isNegativeZero(double value);
+
+	static void initializeFiniteValue(FiniteValue &value);
+
+	static void errorNegativeCount();
+
+	FiniteValue finiteValue_;
+
+	uint64_t negativeZeroCount_;
+	uint64_t positiveInfCount_;
+	uint64_t negativeInfCount_;
+	uint64_t nanCount_;
+
+	uint32_t exponent_;
+	bool sign_;
+};
+
 } 
 
 namespace util {