Use the new uptime code. Replace slow, non-monotonic 'time(NULL)' calls

with fast, almost-always-monotonic 'upTime()' calls.

src/cpp/ripple/KeyCache.h

@@ -6,11 +6,13 @@
 #include <boost/unordered_map.hpp>
 #include <boost/thread/mutex.hpp>
 
+extern int upTime();
+
 template <typename c_Key> class KeyCache
 { // Maintains a cache of keys with no associated data
 public:
 	typedef c_Key									key_type;
-	typedef boost::unordered_map<key_type, time_t>	map_type;
+	typedef boost::unordered_map<key_type, int>		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

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<uint256, LedgerAcquire::pointer>::iterator it = mLedgers.begin();

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);

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<int>(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)

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<LoadCost>	mCosts;
 

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;

src/cpp/ripple/LoadMonitor.h

@@ -7,6 +7,7 @@
 #include <boost/shared_ptr.hpp>
 
 #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);

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<uint256, Suppression>::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<uint256> >::iterator it = mSuppressionTimes.begin();
+	std::map< int, std::list<uint256> >::iterator it = mSuppressionTimes.begin();
 	if ((it != mSuppressionTimes.end()) && (it->first <= expireTime))
 	{
 		BOOST_FOREACH(const uint256& lit, it->second)

src/cpp/ripple/Suppression.h

@@ -50,7 +50,7 @@ protected:
 	boost::unordered_map<uint256, Suppression> mSuppressionMap;
 
 	// Stores all expiration times and the hashes indexed for them
-	std::map< time_t, std::list<uint256> > mSuppressionTimes;
+	std::map< int, std::list<uint256> > mSuppressionTimes;
 
 	int mHoldTime;
 

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<key_type, cache_entry>				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<typename c_Key, typename c_Data> void TaggedCache<c_Key, c_Data>::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<c_Key, c_Data>::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;
 	}