diff --git a/src/cpp/ripple/KeyCache.h b/src/cpp/ripple/KeyCache.h index 63bc2e80c6..13387fb6d2 100644 --- a/src/cpp/ripple/KeyCache.h +++ b/src/cpp/ripple/KeyCache.h @@ -6,11 +6,13 @@ #include #include +extern int upTime(); + template class KeyCache { // Maintains a cache of keys with no associated data public: typedef c_Key key_type; - typedef boost::unordered_map map_type; + typedef boost::unordered_map map_type; typedef typename map_type::iterator map_iterator; protected: @@ -65,7 +67,7 @@ public: if (it == mCache.end()) return false; if (refresh) - it->second = time(NULL); + it->second = upTime(); return true; } @@ -88,19 +90,19 @@ public: map_iterator it = mCache.find(key); if (it != mCache.end()) { - it->second = time(NULL); + it->second = upTime(); return false; } - mCache.insert(std::make_pair(key, time(NULL))); + mCache.insert(std::make_pair(key, upTime())); return true; } void sweep() { // Remove stale entries from the cache - time_t now = time(NULL); + int now = upTime(); boost::mutex::scoped_lock sl(mNCLock); - time_t target; + int target; if ((mTargetSize == 0) || (mCache.size() <= mTargetSize)) target = now - mTargetAge; else diff --git a/src/cpp/ripple/LedgerAcquire.cpp b/src/cpp/ripple/LedgerAcquire.cpp index 75a2e42436..f24c6fe463 100644 --- a/src/cpp/ripple/LedgerAcquire.cpp +++ b/src/cpp/ripple/LedgerAcquire.cpp @@ -22,7 +22,7 @@ DECLARE_INSTANCE(LedgerAcquire); PeerSet::PeerSet(const uint256& hash, int interval) : mHash(hash), mTimerInterval(interval), mTimeouts(0), mComplete(false), mFailed(false), mProgress(true), mAggressive(true), mTimer(theApp->getIOService()) { - mLastAction = time(NULL); + mLastAction = upTime(); assert((mTimerInterval > 10) && (mTimerInterval < 30000)); } @@ -890,7 +890,7 @@ void LedgerAcquireMaster::sweep() { mRecentFailures.sweep(); - time_t now = time(NULL); + int now = upTime(); boost::mutex::scoped_lock sl(mLock); std::map::iterator it = mLedgers.begin(); diff --git a/src/cpp/ripple/LedgerAcquire.h b/src/cpp/ripple/LedgerAcquire.h index 0f2c6abd26..b6d60f0f37 100644 --- a/src/cpp/ripple/LedgerAcquire.h +++ b/src/cpp/ripple/LedgerAcquire.h @@ -32,7 +32,7 @@ protected: uint256 mHash; int mTimerInterval, mTimeouts; bool mComplete, mFailed, mProgress, mAggressive; - time_t mLastAction; + int mLastAction; boost::recursive_mutex mLock; boost::asio::deadline_timer mTimer; @@ -53,8 +53,8 @@ public: bool isActive(); void progress() { mProgress = true; mAggressive = false; } bool isProgress() { return mProgress; } - void touch() { mLastAction = time(NULL); } - time_t getLastAction() { return mLastAction; } + void touch() { mLastAction = upTime(); } + int getLastAction() { return mLastAction; } void peerHas(Peer::ref); void badPeer(Peer::ref); diff --git a/src/cpp/ripple/LoadManager.cpp b/src/cpp/ripple/LoadManager.cpp index 013c7f2af6..79e7eb952e 100644 --- a/src/cpp/ripple/LoadManager.cpp +++ b/src/cpp/ripple/LoadManager.cpp @@ -17,7 +17,7 @@ int upTime() static time_t firstCall = time(NULL); if (uptimePtr != NULL) return *uptimePtr; - cLog(lsWARNING) << "slow uptime"; + cLog(lsTRACE) << "Slow uptime in use"; return static_cast(time(NULL) - firstCall); } @@ -117,7 +117,7 @@ void LoadManager::setDebitLimit(int r) mDebitLimit = r; } -void LoadManager::canonicalize(LoadSource& source, const time_t now) const +void LoadManager::canonicalize(LoadSource& source, int now) const { if (source.mLastUpdate != now) { @@ -133,9 +133,9 @@ void LoadManager::canonicalize(LoadSource& source, const time_t now) const bool LoadManager::shouldWarn(LoadSource& source) const { - time_t now = time(NULL); boost::mutex::scoped_lock sl(mLock); + int now = upTime(); canonicalize(source, now); if (source.isPrivileged() || (source.mBalance < mDebitWarn) || (source.mLastWarning == now)) return false; @@ -146,9 +146,9 @@ bool LoadManager::shouldWarn(LoadSource& source) const bool LoadManager::shouldCutoff(LoadSource& source) const { - time_t now = time(NULL); boost::mutex::scoped_lock sl(mLock); + int now = upTime(); canonicalize(source, now); return !source.isPrivileged() && (source.mBalance < mDebitLimit); } @@ -161,10 +161,10 @@ bool LoadManager::adjust(LoadSource& source, LoadType t) const bool LoadManager::adjust(LoadSource& source, int credits) const { // return: true = need to warn/cutoff - time_t now = time(NULL); boost::mutex::scoped_lock sl(mLock); // We do it this way in case we want to add exponential decay later + int now = upTime(); canonicalize(source, now); source.mBalance += credits; if (source.mBalance > mCreditLimit) diff --git a/src/cpp/ripple/LoadManager.h b/src/cpp/ripple/LoadManager.h index dea9c6c0b4..b64394298f 100644 --- a/src/cpp/ripple/LoadManager.h +++ b/src/cpp/ripple/LoadManager.h @@ -63,12 +63,12 @@ public: protected: int mBalance; int mFlags; - time_t mLastUpdate; - time_t mLastWarning; + int mLastUpdate; + int mLastWarning; public: LoadSource() : mBalance(0), mFlags(0), mLastWarning(0) - { mLastUpdate = time(NULL); } + { mLastUpdate = upTime(); } bool isPrivileged() const { return (mFlags & lsfPrivileged) != 0; } void setPrivileged() { mFlags |= lsfPrivileged; } @@ -89,11 +89,14 @@ protected: int mDebitLimit; // when a source drops below this, we cut it off (should be negative) bool mShutdown; + + int mSpace1[4]; // We want mUptime to have its own cache line int mUptime; + int mSpace2[4]; mutable boost::mutex mLock; - void canonicalize(LoadSource&, const time_t now) const; + void canonicalize(LoadSource&, int upTime) const; std::vector mCosts; diff --git a/src/cpp/ripple/LoadMonitor.cpp b/src/cpp/ripple/LoadMonitor.cpp index 312de87a72..567d08c948 100644 --- a/src/cpp/ripple/LoadMonitor.cpp +++ b/src/cpp/ripple/LoadMonitor.cpp @@ -2,7 +2,7 @@ void LoadMonitor::update() { // call with the mutex - time_t now = time(NULL); + int now = upTime(); if (now == mLastUpdate) // current return; diff --git a/src/cpp/ripple/LoadMonitor.h b/src/cpp/ripple/LoadMonitor.h index efda49b53b..18cbb228dd 100644 --- a/src/cpp/ripple/LoadMonitor.h +++ b/src/cpp/ripple/LoadMonitor.h @@ -7,6 +7,7 @@ #include #include "types.h" +extern int upTime(); // Monitors load levels and response times @@ -19,7 +20,7 @@ protected: uint64 mLatencyMSPeak; uint64 mTargetLatencyAvg; uint64 mTargetLatencyPk; - time_t mLastUpdate; + int mLastUpdate; boost::mutex mLock; void update(); @@ -27,7 +28,7 @@ protected: public: LoadMonitor() : mCounts(0), mLatencyEvents(0), mLatencyMSAvg(0), mLatencyMSPeak(0), mTargetLatencyAvg(0), mTargetLatencyPk(0) - { mLastUpdate = time(NULL); } + { mLastUpdate = upTime(); } void addCount(int counts); void addLatency(int latency); diff --git a/src/cpp/ripple/Suppression.cpp b/src/cpp/ripple/Suppression.cpp index 1bd594d40b..b168b9120f 100644 --- a/src/cpp/ripple/Suppression.cpp +++ b/src/cpp/ripple/Suppression.cpp @@ -4,6 +4,8 @@ DECLARE_INSTANCE(Suppression); +extern int upTime(); + Suppression& SuppressionTable::findCreateEntry(const uint256& index, bool& created) { boost::unordered_map::iterator fit = mSuppressionMap.find(index); @@ -15,11 +17,11 @@ Suppression& SuppressionTable::findCreateEntry(const uint256& index, bool& creat } created = true; - time_t now = time(NULL); - time_t expireTime = now - mHoldTime; + int now = upTime(); + int expireTime = now - mHoldTime; // See if any supressions need to be expired - std::map< time_t, std::list >::iterator it = mSuppressionTimes.begin(); + std::map< int, std::list >::iterator it = mSuppressionTimes.begin(); if ((it != mSuppressionTimes.end()) && (it->first <= expireTime)) { BOOST_FOREACH(const uint256& lit, it->second) diff --git a/src/cpp/ripple/Suppression.h b/src/cpp/ripple/Suppression.h index 4cd9db074f..d401a8f412 100644 --- a/src/cpp/ripple/Suppression.h +++ b/src/cpp/ripple/Suppression.h @@ -50,7 +50,7 @@ protected: boost::unordered_map mSuppressionMap; // Stores all expiration times and the hashes indexed for them - std::map< time_t, std::list > mSuppressionTimes; + std::map< int, std::list > mSuppressionTimes; int mHoldTime; diff --git a/src/cpp/ripple/TaggedCache.h b/src/cpp/ripple/TaggedCache.h index f8cb5d4992..ad6bea2d74 100644 --- a/src/cpp/ripple/TaggedCache.h +++ b/src/cpp/ripple/TaggedCache.h @@ -11,6 +11,7 @@ #include "Log.h" extern LogPartition TaggedCachePartition; +extern int upTime(); // This class implements a cache and a map. The cache keeps objects alive // in the map. The map allows multiple code paths that reference objects @@ -36,15 +37,15 @@ protected: class cache_entry { public: - time_t last_use; + int last_use; data_ptr ptr; weak_data_ptr weak_ptr; - cache_entry(time_t l, const data_ptr& d) : last_use(l), ptr(d), weak_ptr(d) { ; } + cache_entry(int l, const data_ptr& d) : last_use(l), ptr(d), weak_ptr(d) { ; } bool isCached() { return !!ptr; } bool isExpired() { return weak_ptr.expired(); } data_ptr lock() { return weak_ptr.lock(); } - void touch() { last_use = time(NULL); } + void touch() { last_use = upTime(); } }; typedef std::pair cache_pair; @@ -59,11 +60,11 @@ protected: int mCacheCount; // Number of items cached cache_type mCache; // Hold strong reference to recent objects - time_t mLastSweep; + int mLastSweep; public: TaggedCache(const char *name, int size, int age) - : mName(name), mTargetSize(size), mTargetAge(age), mCacheCount(0), mLastSweep(time(NULL)) { ; } + : mName(name), mTargetSize(size), mTargetAge(age), mCacheCount(0), mLastSweep(upTime()) { ; } int getTargetSize() const; int getTargetAge() const; @@ -128,8 +129,8 @@ template void TaggedCache::sweep { boost::recursive_mutex::scoped_lock sl(mLock); - time_t mLastSweep = time(NULL); - time_t target = mLastSweep - mTargetAge; + int mLastSweep = upTime(); + int target = mLastSweep - mTargetAge; int cacheRemovals = 0, mapRemovals = 0, cc = 0; if ((mTargetSize != 0) && (mCache.size() > mTargetSize)) @@ -243,7 +244,7 @@ bool TaggedCache::canonicalize(const key_type& key, boost::shared cache_iterator cit = mCache.find(key); if (cit == mCache.end()) { - mCache.insert(cache_pair(key, cache_entry(time(NULL), data))); + mCache.insert(cache_pair(key, cache_entry(upTime(), data))); ++mCacheCount; return false; }