Automated merge with http://bitbucket.org/lindenlab/viewer-interesting

12 files changed, 194 insertions, 196 deletions

diff --git a/indra/llmessage/llassetstorage.cpp b/indra/llmessage/llassetstorage.cpp
index fe97501658..413266a29d 100755
--- a/indra/llmessage/llassetstorage.cpp
+++ b/indra/llmessage/llassetstorage.cpp
@@ -194,8 +194,8 @@ LLSD LLAssetRequest::getTerseDetails() const
 	sd["asset_id"] = getUUID();
 	sd["type_long"] = LLAssetType::lookupHumanReadable(getType());
 	sd["type"] = LLAssetType::lookup(getType());
-	sd["time"] = mTime;
-	time_t timestamp = (time_t) mTime;
+	sd["time"] = mTime.value();
+	time_t timestamp = (time_t) mTime.value();
 	std::ostringstream time_string;
 	time_string << ctime(&timestamp);
 	sd["time_string"] = time_string.str();
@@ -341,7 +341,7 @@ void LLAssetStorage::checkForTimeouts()
 
 void LLAssetStorage::_cleanupRequests(BOOL all, S32 error)
 {
-	F64 mt_secs = LLMessageSystem::getMessageTimeSeconds();
+	F64Seconds mt_secs = LLMessageSystem::getMessageTimeSeconds();
 
 	request_list_t timed_out;
 	S32 rt;
diff --git a/indra/llmessage/llassetstorage.h b/indra/llmessage/llassetstorage.h
index 6ffd7ad309..6ed1027cee 100755
--- a/indra/llmessage/llassetstorage.h
+++ b/indra/llmessage/llassetstorage.h
@@ -119,8 +119,8 @@ public:
 	BOOL	mIsTemp;
 	BOOL	mIsLocal;
 	BOOL	mIsUserWaiting;		// We don't want to try forever if a user is waiting for a result.
-	F64		mTime;				// Message system time
-	F64		mTimeout;			// Amount of time before timing out.
+	F64Seconds		mTime;				// Message system time
+	F64Seconds		mTimeout;			// Amount of time before timing out.
 	BOOL    mIsPriority;
 	BOOL	mDataSentInFirstPacket;
 	BOOL	mDataIsInVFS;
@@ -163,7 +163,7 @@ public:
 	void	*mUserData;
 	LLHost  mHost;
 	BOOL	mIsTemp;
-	F64		mTime;				// Message system time
+	F64Seconds	mTime;				// Message system time
 	BOOL    mIsPriority;
 	BOOL	mDataSentInFirstPacket;
 	BOOL	mDataIsInVFS;
@@ -193,7 +193,7 @@ public:
 	void	*mUserData;
 	LLHost  mHost;
 	BOOL	mIsTemp;
-	F64		mTime;				// Message system time
+	F64Seconds	mTime;				// Message system time
 	BOOL    mIsPriority;
 	BOOL	mDataSentInFirstPacket;
 	BOOL	mDataIsInVFS;
diff --git a/indra/llmessage/llcircuit.cpp b/indra/llmessage/llcircuit.cpp
index 00e9266d47..1ace4d9b70 100755
--- a/indra/llmessage/llcircuit.cpp
+++ b/indra/llmessage/llcircuit.cpp
@@ -60,12 +60,12 @@
 const S32 PING_START_BLOCK = 3;		// How many pings behind we have to be to consider ourself blocked.
 const S32 PING_RELEASE_BLOCK = 2;	// How many pings behind we have to be to consider ourself unblocked.
 
-const F32 TARGET_PERIOD_LENGTH = 5.f;	// seconds
-const F32 LL_DUPLICATE_SUPPRESSION_TIMEOUT = 60.f; //seconds - this can be long, as time-based cleanup is
+const F32Seconds TARGET_PERIOD_LENGTH(5.f);
+const F32Seconds LL_DUPLICATE_SUPPRESSION_TIMEOUT(60.f); //this can be long, as time-based cleanup is
 													// only done when wrapping packetids, now...
 
 LLCircuitData::LLCircuitData(const LLHost &host, TPACKETID in_id, 
-							 const F32 circuit_heartbeat_interval, const F32 circuit_timeout)
+							 const F32Seconds circuit_heartbeat_interval, const F32Seconds circuit_timeout)
 :	mHost (host),
 	mWrapID(0),
 	mPacketsOutID(0), 
@@ -84,7 +84,7 @@ LLCircuitData::LLCircuitData(const LLHost &host, TPACKETID in_id,
 	mPingsInTransit(0),
 	mLastPingID(0),
 	mPingDelay(INITIAL_PING_VALUE_MSEC), 
-	mPingDelayAveraged((F32)INITIAL_PING_VALUE_MSEC), 
+	mPingDelayAveraged(INITIAL_PING_VALUE_MSEC), 
 	mUnackedPacketCount(0),
 	mUnackedPacketBytes(0),
 	mLastPacketInTime(0.0),
@@ -110,13 +110,13 @@ LLCircuitData::LLCircuitData(const LLHost &host, TPACKETID in_id,
 {
 	// Need to guarantee that this time is up to date, we may be creating a circuit even though we haven't been
 	//  running a message system loop.
-	F64 mt_sec = LLMessageSystem::getMessageTimeSeconds(TRUE);
+	F64Seconds mt_sec = LLMessageSystem::getMessageTimeSeconds(TRUE);
 	F32 distribution_offset = ll_frand();
 	
 	mPingTime = mt_sec;
 	mLastPingSendTime = mt_sec + mHeartbeatInterval * distribution_offset;
 	mLastPingReceivedTime = mt_sec;
-	mNextPingSendTime = mLastPingSendTime + 0.95*mHeartbeatInterval + ll_frand(0.1f*mHeartbeatInterval);
+	mNextPingSendTime = mLastPingSendTime + 0.95*mHeartbeatInterval + F32Seconds(ll_frand(0.1f*mHeartbeatInterval.value()));
 	mPeriodTime = mt_sec;
 
 	mLocalEndPointID.generate();
@@ -268,7 +268,7 @@ void LLCircuitData::ackReliablePacket(TPACKETID packet_num)
 
 
 
-S32 LLCircuitData::resendUnackedPackets(const F64 now)
+S32 LLCircuitData::resendUnackedPackets(const F64Seconds now)
 {
 	S32 resent_packets = 0;
 	LLReliablePacket *packetp;
@@ -355,7 +355,7 @@ S32 LLCircuitData::resendUnackedPackets(const F64 now)
 			// The new method, retry time based on ping
 			if (packetp->mPingBasedRetry)
 			{
-				packetp->mExpirationTime = now + llmax(LL_MINIMUM_RELIABLE_TIMEOUT_SECONDS, (LL_RELIABLE_TIMEOUT_FACTOR * getPingDelayAveraged()));
+				packetp->mExpirationTime = now + llmax(LL_MINIMUM_RELIABLE_TIMEOUT_SECONDS, F32Seconds(LL_RELIABLE_TIMEOUT_FACTOR * getPingDelayAveraged()));
 			}
 			else
 			{
@@ -427,10 +427,11 @@ S32 LLCircuitData::resendUnackedPackets(const F64 now)
 }
 
 
-LLCircuit::LLCircuit(const F32 circuit_heartbeat_interval, const F32 circuit_timeout) : mLastCircuit(NULL),  
-	mHeartbeatInterval(circuit_heartbeat_interval), mHeartbeatTimeout(circuit_timeout)
-{
-}
+LLCircuit::LLCircuit(const F32Seconds circuit_heartbeat_interval, const F32Seconds circuit_timeout) 
+:	mLastCircuit(NULL),  
+	mHeartbeatInterval(circuit_heartbeat_interval), 
+	mHeartbeatTimeout(circuit_timeout)
+{}
 
 LLCircuit::~LLCircuit()
 {
@@ -521,17 +522,17 @@ void LLCircuitData::setAllowTimeout(BOOL allow)
 // Reset per-period counters if necessary.
 void LLCircuitData::checkPeriodTime()
 {
-	F64 mt_sec = LLMessageSystem::getMessageTimeSeconds();
-	F64 period_length = mt_sec - mPeriodTime;
+	F64Seconds mt_sec = LLMessageSystem::getMessageTimeSeconds();
+	F64Seconds period_length = mt_sec - mPeriodTime;
 	if ( period_length > TARGET_PERIOD_LENGTH)
 	{
-		F32 bps_in = (F32)(mBytesInThisPeriod * 8.f / period_length);
+		F32 bps_in = F32Bits(mBytesInThisPeriod).value() / period_length.value();
 		if (bps_in > mPeakBPSIn)
 		{
 			mPeakBPSIn = bps_in;
 		}
 
-		F32 bps_out = (F32)(mBytesOutThisPeriod * 8.f / period_length);
+		F32 bps_out = F32Bits(mBytesOutThisPeriod).value() / period_length.value();
 		if (bps_out > mPeakBPSOut)
 		{
 			mPeakBPSOut = bps_out;
@@ -541,7 +542,7 @@ void LLCircuitData::checkPeriodTime()
 		mBytesOutLastPeriod	= mBytesOutThisPeriod;
 		mBytesInThisPeriod	= 0;
 		mBytesOutThisPeriod	= 0;
-		mLastPeriodLength	= (F32)period_length;
+		mLastPeriodLength	= period_length;
 
 		mPeriodTime = mt_sec;
 	}
@@ -584,7 +585,7 @@ void LLCircuitData::addReliablePacket(S32 mSocket, U8 *buf_ptr, S32 buf_len, LLR
 
 void LLCircuit::resendUnackedPackets(S32& unacked_list_length, S32& unacked_list_size)
 {
-	F64 now = LLMessageSystem::getMessageTimeSeconds();
+	F64Seconds now = LLMessageSystem::getMessageTimeSeconds();
 	unacked_list_length = 0;
 	unacked_list_size = 0;
 
@@ -726,7 +727,7 @@ void LLCircuitData::checkPacketInID(TPACKETID id, BOOL receive_resent)
 		}
 		else if (!receive_resent) // don't freak out over out-of-order reliable resends
 		{
-			U64 time = LLMessageSystem::getMessageTimeUsecs();
+			U64Microseconds time = LLMessageSystem::getMessageTimeUsecs();
 			TPACKETID index = mPacketsInID;
 			S32 gap_count = 0;
 			if ((index < id) && ((id - index) < 16))
@@ -742,7 +743,7 @@ void LLCircuitData::checkPacketInID(TPACKETID id, BOOL receive_resent)
 					}
 
 //						LL_INFOS() << "adding potential lost: " << index << LL_ENDL;
-					mPotentialLostPackets[index] = time;
+					mPotentialLostPackets[index] = time.value();
 					index++;
 					index = index % LL_MAX_OUT_PACKET_ID;
 					gap_count++;
@@ -780,7 +781,7 @@ void LLCircuitData::checkPacketInID(TPACKETID id, BOOL receive_resent)
 
 void LLCircuit::updateWatchDogTimers(LLMessageSystem *msgsys)
 {
-	F64 cur_time = LLMessageSystem::getMessageTimeSeconds();
+	F64Seconds cur_time = LLMessageSystem::getMessageTimeSeconds();
 	S32 count = mPingSet.size();
 	S32 cur = 0;
 
@@ -818,7 +819,7 @@ void LLCircuit::updateWatchDogTimers(LLMessageSystem *msgsys)
 			if (cdp->updateWatchDogTimers(msgsys))
             {
 				// Randomize our pings a bit by doing some up to 5% early or late
-				F64 dt = 0.95f*mHeartbeatInterval + ll_frand(0.1f*mHeartbeatInterval);
+				F64Seconds dt = 0.95f*mHeartbeatInterval + F32Seconds(ll_frand(0.1f*mHeartbeatInterval.value()));
 
 				// Remove it, and reinsert it with the new next ping time.
 				// Always remove before changing the sorting key.
@@ -846,7 +847,7 @@ void LLCircuit::updateWatchDogTimers(LLMessageSystem *msgsys)
 
 BOOL LLCircuitData::updateWatchDogTimers(LLMessageSystem *msgsys)
 {
-	F64 cur_time = LLMessageSystem::getMessageTimeSeconds();
+	F64Seconds cur_time = LLMessageSystem::getMessageTimeSeconds();
 	mLastPingSendTime = cur_time;
 
 	if (!checkCircuitTimeout())
@@ -963,12 +964,12 @@ BOOL LLCircuitData::updateWatchDogTimers(LLMessageSystem *msgsys)
 	// be considered lost
 
 	LLCircuitData::packet_time_map::iterator it;
-	U64 timeout = (U64)(1000000.0*llmin(LL_MAX_LOST_TIMEOUT, getPingDelayAveraged() * LL_LOST_TIMEOUT_FACTOR));
+	U64Microseconds timeout = llmin(LL_MAX_LOST_TIMEOUT, F32Seconds(getPingDelayAveraged()) * LL_LOST_TIMEOUT_FACTOR);
 
-	U64 mt_usec = LLMessageSystem::getMessageTimeUsecs();
+	U64Microseconds mt_usec = LLMessageSystem::getMessageTimeUsecs();
 	for (it = mPotentialLostPackets.begin(); it != mPotentialLostPackets.end(); )
 	{
-		U64 delta_t_usec = mt_usec - (*it).second;
+		U64Microseconds delta_t_usec = mt_usec - (*it).second;
 		if (delta_t_usec > timeout)
 		{
 			// let's call this one a loss!
@@ -1014,7 +1015,7 @@ void LLCircuitData::clearDuplicateList(TPACKETID oldest_id)
 	// Do timeout checks on everything with an ID > mHighestPacketID.
 	// This should be empty except for wrapping IDs.  Thus, this should be
 	// highly rare.
-	U64 mt_usec = LLMessageSystem::getMessageTimeUsecs();
+	U64Microseconds mt_usec = LLMessageSystem::getMessageTimeUsecs();
 
 	packet_time_map::iterator pit;
 	for(pit = mRecentlyReceivedReliablePackets.upper_bound(mHighestPacketID);
@@ -1025,8 +1026,8 @@ void LLCircuitData::clearDuplicateList(TPACKETID oldest_id)
 		{
 			LL_WARNS() << "Probably incorrectly timing out non-wrapped packets!" << LL_ENDL;
 		}
-		U64 delta_t_usec = mt_usec - (*pit).second;
-		F64 delta_t_sec = delta_t_usec * SEC_PER_USEC;
+		U64Microseconds delta_t_usec = mt_usec - (*pit).second;
+		F64Seconds delta_t_sec = delta_t_usec;
 		if (delta_t_sec > LL_DUPLICATE_SUPPRESSION_TIMEOUT)
 		{
 			// enough time has elapsed we're not likely to get a duplicate on this one
@@ -1043,7 +1044,7 @@ void LLCircuitData::clearDuplicateList(TPACKETID oldest_id)
 
 BOOL LLCircuitData::checkCircuitTimeout()
 {
-	F64 time_since_last_ping = LLMessageSystem::getMessageTimeSeconds() - mLastPingReceivedTime;
+	F64Seconds time_since_last_ping = LLMessageSystem::getMessageTimeSeconds() - mLastPingReceivedTime;
 
 	// Nota Bene: This needs to be turned off if you are debugging multiple simulators
 	if (time_since_last_ping > mHeartbeatTimeout)
@@ -1139,40 +1140,40 @@ std::ostream& operator<<(std::ostream& s, LLCircuitData& circuit)
 	F32 age = circuit.mExistenceTimer.getElapsedTimeF32();
 
 	using namespace std;
-	s << "Circuit " << circuit.mHost << " ";
-	s << circuit.mRemoteID << " ";
-	s << (circuit.mbAlive ? "Alive" : "Not Alive") << " ";
-	s << (circuit.mbAllowTimeout ? "Timeout Allowed" : "Timeout Not Allowed");
-	s << endl;
-
-	s << " Packets Lost: " << circuit.mPacketsLost;
-	s << " Measured Ping: " << circuit.mPingDelay;
-	s << " Averaged Ping: " << circuit.mPingDelayAveraged;
-	s << endl;
-
-	s << "Global In/Out " << S32(age) << " sec";
-	s << " KBytes: " << circuit.mBytesIn / 1024 << "/" << circuit.mBytesOut / 1024;
-	s << " Kbps: ";
-	s << S32(circuit.mBytesIn * 8.f / circuit.mExistenceTimer.getElapsedTimeF32() / 1024.f);
-	s << "/";
-	s << S32(circuit.mBytesOut * 8.f / circuit.mExistenceTimer.getElapsedTimeF32() / 1024.f);
-	s << " Packets: " << circuit.mPacketsIn << "/" << circuit.mPacketsOut;
-	s << endl;
-
-	s << "Recent In/Out   " << S32(circuit.mLastPeriodLength) << " sec";
-	s << " KBytes: ";
-	s << circuit.mBytesInLastPeriod / 1024;
-	s << "/";
-	s << circuit.mBytesOutLastPeriod / 1024;
-	s << " Kbps: ";
-	s << S32(circuit.mBytesInLastPeriod * 8.f / circuit.mLastPeriodLength / 1024.f);
-	s << "/";
-	s << S32(circuit.mBytesOutLastPeriod * 8.f / circuit.mLastPeriodLength / 1024.f);
-	s << " Peak kbps: ";
-	s << S32(circuit.mPeakBPSIn / 1024.f);
-	s << "/";
-	s << S32(circuit.mPeakBPSOut / 1024.f);
-	s << endl;
+	s << "Circuit " << circuit.mHost << " "
+		<< circuit.mRemoteID << " "
+		<< (circuit.mbAlive ? "Alive" : "Not Alive") << " "
+		<< (circuit.mbAllowTimeout ? "Timeout Allowed" : "Timeout Not Allowed")
+		<< endl;
+
+	s << " Packets Lost: " << circuit.mPacketsLost
+		<< " Measured Ping: " << circuit.mPingDelay
+		<< " Averaged Ping: " << circuit.mPingDelayAveraged
+		<< endl;
+
+	s << "Global In/Out " << S32(age) << " sec"
+		<< " KBytes: " << circuit.mBytesIn.valueInUnits<LLUnits::Kibibytes>() << "/" << circuit.mBytesOut.valueInUnits<LLUnits::Kibibytes>()
+		<< " Kbps: "
+		<< S32(circuit.mBytesIn.valueInUnits<LLUnits::Kibibits>() / circuit.mExistenceTimer.getElapsedTimeF32().value())
+		<< "/"
+		<< S32(circuit.mBytesOut.valueInUnits<LLUnits::Kibibits>() / circuit.mExistenceTimer.getElapsedTimeF32().value())
+		<< " Packets: " << circuit.mPacketsIn << "/" << circuit.mPacketsOut
+		<< endl;
+
+	s << "Recent In/Out   " << circuit.mLastPeriodLength
+		<< " KBytes: "
+		<< circuit.mBytesInLastPeriod.valueInUnits<LLUnits::Kibibytes>()
+		<< "/"
+		<< circuit.mBytesOutLastPeriod.valueInUnits<LLUnits::Kibibytes>()
+		<< " Kbps: "
+		<< (S32)(circuit.mBytesInLastPeriod.valueInUnits<LLUnits::Kibibits>() / circuit.mLastPeriodLength.value())
+		<< "/"
+		<< (S32)(circuit.mBytesOutLastPeriod.valueInUnits<LLUnits::Kibibits>() / circuit.mLastPeriodLength.value())
+		<< " Peak kbps: "
+		<< S32(circuit.mPeakBPSIn / 1024.f)
+		<< "/"
+		<< S32(circuit.mPeakBPSOut / 1024.f)
+		<< endl;
 
 	return s;
 }
@@ -1256,10 +1257,10 @@ void LLCircuitData::setPacketInID(TPACKETID id)
 
 void LLCircuitData::pingTimerStop(const U8 ping_id)
 {
-	F64 mt_secs = LLMessageSystem::getMessageTimeSeconds();
+	F64Seconds mt_secs = LLMessageSystem::getMessageTimeSeconds();
 
 	// Nota Bene: no averaging of ping times until we get a feel for how this works
-	F64 time = mt_secs - mPingTime;
+	F64Seconds time = mt_secs - mPingTime;
 	if (time == 0.0)
 	{
 		// Ack, we got our ping response on the same frame! Sigh, let's get a real time otherwise
@@ -1276,7 +1277,7 @@ void LLCircuitData::pingTimerStop(const U8 ping_id)
 		delta_ping += 256;
 	}
 
-	U32 msec = (U32) ((delta_ping*mHeartbeatInterval  + time) * 1000.f);
+	U32Milliseconds msec = delta_ping*mHeartbeatInterval + time;
 	setPingDelay(msec);
 
 	mPingsInTransit = delta_ping;
@@ -1305,13 +1306,13 @@ U32 LLCircuitData::getPacketsIn() const
 }
 
 
-S32 LLCircuitData::getBytesIn() const
+S32Bytes LLCircuitData::getBytesIn() const
 {
 	return mBytesIn;
 }
 
 
-S32 LLCircuitData::getBytesOut() const
+S32Bytes LLCircuitData::getBytesOut() const
 {
 	return mBytesOut;
 }
@@ -1353,41 +1354,41 @@ BOOL LLCircuitData::getAllowTimeout() const
 }
 
 
-U32 LLCircuitData::getPingDelay() const
+U32Milliseconds LLCircuitData::getPingDelay() const
 {
 	return mPingDelay;
 }
 
 
-F32 LLCircuitData::getPingInTransitTime()
+F32Milliseconds LLCircuitData::getPingInTransitTime()
 {
 	// This may be inaccurate in the case of a circuit that was "dead" and then revived,
 	// but only until the first round trip ping is sent - djs
-	F32 time_since_ping_was_sent = 0;
+	F32Milliseconds time_since_ping_was_sent(0);
 
 	if (mPingsInTransit)
 	{
-		time_since_ping_was_sent =  (F32)((mPingsInTransit*mHeartbeatInterval - 1) 
-			+ (LLMessageSystem::getMessageTimeSeconds() - mPingTime))*1000.f;
+		time_since_ping_was_sent =  ((mPingsInTransit*mHeartbeatInterval - 1) 
+			+ (LLMessageSystem::getMessageTimeSeconds() - mPingTime));
 	}
 
 	return time_since_ping_was_sent;
 }
 
 
-void LLCircuitData::setPingDelay(U32 ping)
+void LLCircuitData::setPingDelay(U32Milliseconds ping)
 {
 	mPingDelay = ping;
-	mPingDelayAveraged = llmax((F32)ping, getPingDelayAveraged());
+	mPingDelayAveraged = llmax((F32Milliseconds)ping, getPingDelayAveraged());
 	mPingDelayAveraged = ((1.f - LL_AVERAGED_PING_ALPHA) * mPingDelayAveraged) 
-						  + (LL_AVERAGED_PING_ALPHA * (F32) ping);
+						  + (LL_AVERAGED_PING_ALPHA * (F32Milliseconds) ping);
 	mPingDelayAveraged = llclamp(mPingDelayAveraged, 
 								 LL_AVERAGED_PING_MIN,
 								 LL_AVERAGED_PING_MAX);
 }
 
 
-F32 LLCircuitData::getPingDelayAveraged()
+F32Milliseconds LLCircuitData::getPingDelayAveraged()
 {
 	return llmin(llmax(getPingInTransitTime(), mPingDelayAveraged), LL_AVERAGED_PING_MAX);
 }
diff --git a/indra/llmessage/llcircuit.h b/indra/llmessage/llcircuit.h
index 11d4e1b11c..bc29805859 100755
--- a/indra/llmessage/llcircuit.h
+++ b/indra/llmessage/llcircuit.h
@@ -44,10 +44,10 @@
 // Constants
 //
 const F32 LL_AVERAGED_PING_ALPHA = 0.2f;  // relaxation constant on ping running average
-const F32 LL_AVERAGED_PING_MAX = 2000;    // msec
-const F32 LL_AVERAGED_PING_MIN =  100;    // msec  // IW: increased to avoid retransmits when a process is slow
+const F32Milliseconds LL_AVERAGED_PING_MAX(2000);    
+const F32Milliseconds LL_AVERAGED_PING_MIN(100);    // increased to avoid retransmits when a process is slow
 
-const U32 INITIAL_PING_VALUE_MSEC = 1000; // initial value for the ping delay, or for ping delay for an unknown circuit
+const U32Milliseconds INITIAL_PING_VALUE_MSEC(1000); // initial value for the ping delay, or for ping delay for an unknown circuit
 
 const TPACKETID LL_MAX_OUT_PACKET_ID = 0x01000000;
 const int LL_ERR_CIRCUIT_GONE   = -23017;
@@ -77,10 +77,10 @@ class LLCircuitData
 {
 public:
 	LLCircuitData(const LLHost &host, TPACKETID in_id, 
-				  const F32 circuit_heartbeat_interval, const F32 circuit_timeout);
+				  const F32Seconds circuit_heartbeat_interval, const F32Seconds circuit_timeout);
 	~LLCircuitData();
 
-	S32		resendUnackedPackets(const F64 now);
+	S32		resendUnackedPackets(const F64Seconds now);
 	void	clearDuplicateList(TPACKETID oldest_id);
 
 
@@ -106,18 +106,18 @@ public:
 	// mLocalEndPointID should only ever be setup in the LLCircuitData constructor
 	const		LLUUID& getLocalEndPointID() const { return mLocalEndPointID; }
 
-	U32		getPingDelay() const;
+	U32Milliseconds	getPingDelay() const;
 	S32				getPingsInTransit() const			{ return mPingsInTransit; }
 
 	// ACCESSORS
 	BOOL		isAlive() const;
 	BOOL		isBlocked() const;
 	BOOL		getAllowTimeout() const;
-	F32			getPingDelayAveraged();
-	F32			getPingInTransitTime();
+	F32Milliseconds	getPingDelayAveraged();
+	F32Milliseconds	getPingInTransitTime();
 	U32			getPacketsIn() const;
-	S32			getBytesIn() const;
-	S32			getBytesOut() const;
+	S32Bytes	getBytesIn() const;
+	S32Bytes	getBytesOut() const;
 	U32			getPacketsOut() const;
 	U32			getPacketsLost() const;
 	TPACKETID	getPacketOutID() const;
@@ -125,10 +125,10 @@ public:
 	F32			getAgeInSeconds() const;
 	S32			getUnackedPacketCount() const	{ return mUnackedPacketCount; }
 	S32			getUnackedPacketBytes() const	{ return mUnackedPacketBytes; }
-	F64         getNextPingSendTime() const { return mNextPingSendTime; }
+	F64Seconds  getNextPingSendTime() const { return mNextPingSendTime; }
     U32         getLastPacketGap() const { return mLastPacketGap; }
     LLHost      getHost() const { return mHost; }
-	F64			getLastPacketInTime() const		{ return mLastPacketInTime;	}
+	F64Seconds	getLastPacketInTime() const		{ return mLastPacketInTime;	}
 
 	LLThrottleGroup &getThrottleGroup()		{	return mThrottles; }
 
@@ -164,7 +164,7 @@ protected:
 	TPACKETID		nextPacketOutID();
 	void				setPacketInID(TPACKETID id);
 	void					checkPacketInID(TPACKETID id, BOOL receive_resent);
-	void			setPingDelay(U32 ping);
+	void			setPingDelay(U32Milliseconds ping);
 	BOOL			checkCircuitTimeout();	// Return FALSE if the circuit is dead and should be cleaned up
 
 	void			addBytesIn(S32 bytes);
@@ -219,20 +219,20 @@ protected:
 	BOOL	mBlocked;					// Blocked is true if the circuit is hosed, i.e. far behind on pings
 
 	// Not sure what the difference between this and mLastPingSendTime is
-	F64		mPingTime;					// Time at which a ping was sent.
+	F64Seconds	mPingTime;					// Time at which a ping was sent.
 
-	F64		mLastPingSendTime;			// Time we last sent a ping
-	F64		mLastPingReceivedTime;		// Time we last received a ping
-	F64     mNextPingSendTime;          // Time to try and send the next ping
-	S32		mPingsInTransit;			// Number of pings in transit
-	U8		mLastPingID;				// ID of the last ping that we sent out
+	F64Seconds	mLastPingSendTime;			// Time we last sent a ping
+	F64Seconds	mLastPingReceivedTime;		// Time we last received a ping
+	F64Seconds  mNextPingSendTime;          // Time to try and send the next ping
+	S32			mPingsInTransit;			// Number of pings in transit
+	U8			mLastPingID;				// ID of the last ping that we sent out
 
 
 	// Used for determining the resend time for reliable resends.
-	U32		mPingDelay;             // raw ping delay
-	F32		mPingDelayAveraged;     // averaged ping delay (fast attack/slow decay)
+	U32Milliseconds		mPingDelay;             // raw ping delay
+	F32Milliseconds		mPingDelayAveraged;     // averaged ping delay (fast attack/slow decay)
 
-	typedef std::map<TPACKETID, U64> packet_time_map;
+	typedef std::map<TPACKETID, U64Microseconds> packet_time_map;
 
 	packet_time_map							mPotentialLostPackets;
 	packet_time_map							mRecentlyReceivedReliablePackets;
@@ -247,7 +247,7 @@ protected:
 	S32										mUnackedPacketCount;
 	S32										mUnackedPacketBytes;
 
-	F64										mLastPacketInTime;		// Time of last packet arrival
+	F64Seconds								mLastPacketInTime;		// Time of last packet arrival
 
 	LLUUID									mLocalEndPointID;
 
@@ -259,24 +259,24 @@ protected:
 	U32		mPacketsOut;
 	U32		mPacketsIn;
 	S32		mPacketsLost;
-	S32		mBytesIn;
-	S32		mBytesOut;
-
-	F32		mLastPeriodLength;		// seconds
-	S32		mBytesInLastPeriod;
-	S32		mBytesOutLastPeriod;
-	S32		mBytesInThisPeriod;
-	S32		mBytesOutThisPeriod;
+	S32Bytes	mBytesIn,
+				mBytesOut;
+
+	F32Seconds	mLastPeriodLength;	
+	S32Bytes	mBytesInLastPeriod;
+	S32Bytes	mBytesOutLastPeriod;
+	S32Bytes	mBytesInThisPeriod;
+	S32Bytes	mBytesOutThisPeriod;
 	F32		mPeakBPSIn;				// bits per second, max of all period bps
 	F32		mPeakBPSOut;			// bits per second, max of all period bps
-	F64		mPeriodTime;
+	F64Seconds	mPeriodTime;
 	LLTimer	mExistenceTimer;	    // initialized when circuit created, used to track bandwidth numbers
 
 	S32		mCurrentResendCount;	// Number of resent packets since last spam
     U32     mLastPacketGap;         // Gap in sequence number of last packet.
 
-	const F32 mHeartbeatInterval;
-	const F32 mHeartbeatTimeout;
+	const F32Seconds mHeartbeatInterval;
+	const F32Seconds mHeartbeatTimeout;
 };
 
 
@@ -286,7 +286,7 @@ class LLCircuit
 {
 public:
 	// CREATORS
-	LLCircuit(const F32 circuit_heartbeat_interval, const F32 circuit_timeout);
+	LLCircuit(const F32Seconds circuit_heartbeat_interval, const F32Seconds circuit_timeout);
 	~LLCircuit();
 
 	// ACCESSORS
@@ -341,7 +341,7 @@ protected:
 	mutable LLCircuitData* mLastCircuit;
 
 private:
-	const F32 mHeartbeatInterval;
-	const F32 mHeartbeatTimeout;
+	const F32Seconds mHeartbeatInterval;
+	const F32Seconds mHeartbeatTimeout;
 };
 #endif
diff --git a/indra/llmessage/llhttpassetstorage.cpp b/indra/llmessage/llhttpassetstorage.cpp
index 0479f0fd32..d9b537941b 100755
--- a/indra/llmessage/llhttpassetstorage.cpp
+++ b/indra/llmessage/llhttpassetstorage.cpp
@@ -1064,7 +1064,7 @@ void LLHTTPAssetStorage::bumpTimedOutUploads()
 {
 	bool user_waiting=FALSE;
 
-	F64 mt_secs = LLMessageSystem::getMessageTimeSeconds();
+	F64Seconds mt_secs = LLMessageSystem::getMessageTimeSeconds();
 
 	if (mPendingUploads.size())
 	{
diff --git a/indra/llmessage/llpacketack.cpp b/indra/llmessage/llpacketack.cpp
index f08d3404ea..c3c022c297 100755
--- a/indra/llmessage/llpacketack.cpp
+++ b/indra/llmessage/llpacketack.cpp
@@ -50,7 +50,7 @@ LLReliablePacket::LLReliablePacket(
 		mHost = params->mHost;
 		mRetries = params->mRetries;
 		mPingBasedRetry = params->mPingBasedRetry;
-		mTimeout = params->mTimeout;
+		mTimeout = F32Seconds(params->mTimeout);
 		mCallback = params->mCallback;
 		mCallbackData = params->mCallbackData;
 		mMessageName = params->mMessageName;
@@ -59,13 +59,13 @@ LLReliablePacket::LLReliablePacket(
 	{
 		mRetries = 0;
 		mPingBasedRetry = TRUE;
-		mTimeout = 0.f;
+		mTimeout = F32Seconds(0.f);
 		mCallback = NULL;
 		mCallbackData = NULL;
 		mMessageName = NULL;
 	}
 
-	mExpirationTime = (F64)((S64)totalTime())/1000000.0 + mTimeout;
+	mExpirationTime = (F64Seconds)totalTime() + mTimeout;
 	mPacketID = ntohl(*((U32*)(&buf_ptr[PHL_PACKET_ID])));
 
 	mSocket = socket;
diff --git a/indra/llmessage/llpacketack.h b/indra/llmessage/llpacketack.h
index 2ef3c48e44..0a5604f74f 100755
--- a/indra/llmessage/llpacketack.h
+++ b/indra/llmessage/llpacketack.h
@@ -28,6 +28,7 @@
 #define LL_LLPACKETACK_H
 
 #include "llhost.h"
+#include "llunit.h"
 
 class LLReliablePacketParams
 {
@@ -35,7 +36,7 @@ public:
 	LLHost mHost;
 	S32 mRetries;
 	BOOL mPingBasedRetry;
-	F32 mTimeout;
+	F32Seconds mTimeout;
 	void (*mCallback)(void **,S32);
 	void** mCallbackData;
 	char* mMessageName;
@@ -63,7 +64,7 @@ public:
 		const LLHost& host,
 		S32 retries,
 		BOOL ping_based_retry,
-		F32 timeout, 
+		F32Seconds timeout, 
 		void (*callback)(void**,S32),
 		void** callback_data, char* name)
 	{
@@ -98,7 +99,7 @@ protected:
 	LLHost mHost;
 	S32 mRetries;
 	BOOL mPingBasedRetry;
-	F32 mTimeout;
+	F32Seconds mTimeout;
 	void (*mCallback)(void**,S32);
 	void** mCallbackData;
 	char* mMessageName;
@@ -108,7 +109,7 @@ protected:
 
 	TPACKETID mPacketID;
 
-	F64 mExpirationTime;
+	F64Seconds mExpirationTime;
 };
 
 #endif
diff --git a/indra/llmessage/llthrottle.cpp b/indra/llmessage/llthrottle.cpp
index 181c594205..00eaa7e2ec 100755
--- a/indra/llmessage/llthrottle.cpp
+++ b/indra/llmessage/llthrottle.cpp
@@ -53,8 +53,8 @@ F32 LLThrottle::getAvailable()
 {
 	// use a temporary bits_available
 	// since we don't want to change mBitsAvailable every time
-	F32 elapsed_time = (F32)(LLMessageSystem::getMessageTimeSeconds() - mLastSendTime);
-	return mAvailable + (mRate * elapsed_time);
+	F32Seconds elapsed_time = LLMessageSystem::getMessageTimeSeconds() - mLastSendTime;
+	return mAvailable + (mRate * elapsed_time.value());
 }
 
 BOOL LLThrottle::checkOverflow(const F32 amount)
@@ -65,8 +65,8 @@ BOOL LLThrottle::checkOverflow(const F32 amount)
 
 	// use a temporary bits_available
 	// since we don't want to change mBitsAvailable every time
-	F32 elapsed_time =  (F32)(LLMessageSystem::getMessageTimeSeconds() - mLastSendTime);
-	F32 amount_available = mAvailable + (mRate * elapsed_time);
+	F32Seconds elapsed_time =  LLMessageSystem::getMessageTimeSeconds() - mLastSendTime;
+	F32 amount_available = mAvailable + (mRate * elapsed_time.value());
 
 	if ((amount_available >= lookahead_amount) || (amount_available > amount))
 	{
@@ -80,17 +80,17 @@ BOOL LLThrottle::checkOverflow(const F32 amount)
 
 BOOL LLThrottle::throttleOverflow(const F32 amount)
 {
-	F32 elapsed_time;
+	F32Seconds elapsed_time;
 	F32 lookahead_amount;
 	BOOL retval = TRUE;
 
 	lookahead_amount = mRate * mLookaheadSecs;
 
-	F64 mt_sec = LLMessageSystem::getMessageTimeSeconds();
-	elapsed_time = (F32)(mt_sec - mLastSendTime);
+	F64Seconds mt_sec = LLMessageSystem::getMessageTimeSeconds();
+	elapsed_time = mt_sec - mLastSendTime;
 	mLastSendTime = mt_sec;
 
-	mAvailable += mRate * elapsed_time;
+	mAvailable += mRate * elapsed_time.value();
 
 	if (mAvailable >= lookahead_amount)
 	{
@@ -222,7 +222,7 @@ void LLThrottleGroup::unpackThrottle(LLDataPacker &dp)
 // into NOT resetting the system.
 void LLThrottleGroup::resetDynamicAdjust()
 {
-	F64 mt_sec = LLMessageSystem::getMessageTimeSeconds();
+	F64Seconds mt_sec = LLMessageSystem::getMessageTimeSeconds();
 	S32 i;
 	for (i = 0; i < TC_EOF; i++)
 	{
@@ -269,8 +269,8 @@ S32		LLThrottleGroup::getAvailable(S32 throttle_cat)
 
 	// use a temporary bits_available
 	// since we don't want to change mBitsAvailable every time
-	F32 elapsed_time = (F32)(LLMessageSystem::getMessageTimeSeconds() - mLastSendTime[throttle_cat]);
-	F32 bits_available = mBitsAvailable[throttle_cat] + (category_bps * elapsed_time);
+	F32Seconds elapsed_time = LLMessageSystem::getMessageTimeSeconds() - mLastSendTime[throttle_cat];
+	F32 bits_available = mBitsAvailable[throttle_cat] + (category_bps * elapsed_time.value());
 
 	if (bits_available >= lookahead_bits)
 	{
@@ -294,8 +294,8 @@ BOOL LLThrottleGroup::checkOverflow(S32 throttle_cat, F32 bits)
 
 	// use a temporary bits_available
 	// since we don't want to change mBitsAvailable every time
-	F32 elapsed_time = (F32)(LLMessageSystem::getMessageTimeSeconds() - mLastSendTime[throttle_cat]);
-	F32 bits_available = mBitsAvailable[throttle_cat] + (category_bps * elapsed_time);
+	F32Seconds elapsed_time = LLMessageSystem::getMessageTimeSeconds() - mLastSendTime[throttle_cat];
+	F32 bits_available = mBitsAvailable[throttle_cat] + (category_bps * elapsed_time.value());
 
 	if (bits_available >= lookahead_bits)
 	{
@@ -315,7 +315,7 @@ BOOL LLThrottleGroup::checkOverflow(S32 throttle_cat, F32 bits)
 
 BOOL LLThrottleGroup::throttleOverflow(S32 throttle_cat, F32 bits)
 {
-	F32 elapsed_time;
+	F32Seconds elapsed_time;
 	F32 category_bps;
 	F32 lookahead_bits;
 	BOOL retval = TRUE;
@@ -323,10 +323,10 @@ BOOL LLThrottleGroup::throttleOverflow(S32 throttle_cat, F32 bits)
 	category_bps = mCurrentBPS[throttle_cat];
 	lookahead_bits = category_bps * THROTTLE_LOOKAHEAD_TIME;
 
-	F64 mt_sec = LLMessageSystem::getMessageTimeSeconds();
-	elapsed_time = (F32)(mt_sec - mLastSendTime[throttle_cat]);
+	F64Seconds mt_sec = LLMessageSystem::getMessageTimeSeconds();
+	elapsed_time = mt_sec - mLastSendTime[throttle_cat];
 	mLastSendTime[throttle_cat] = mt_sec;
-	mBitsAvailable[throttle_cat] += category_bps * elapsed_time;
+	mBitsAvailable[throttle_cat] += category_bps * elapsed_time.value();
 
 	if (mBitsAvailable[throttle_cat] >= lookahead_bits)
 	{
@@ -365,7 +365,7 @@ BOOL LLThrottleGroup::dynamicAdjust()
 
 	S32 i;
 
-	F64 mt_sec = LLMessageSystem::getMessageTimeSeconds();
+	F64Seconds mt_sec = LLMessageSystem::getMessageTimeSeconds();
 
 	// Only dynamically adjust every few seconds
 	if ((mt_sec - mDynamicAdjustTime) < DYNAMIC_ADJUST_TIME)
diff --git a/indra/llmessage/llthrottle.h b/indra/llmessage/llthrottle.h
index ed0aeb4602..e43e54f61b 100755
--- a/indra/llmessage/llthrottle.h
+++ b/indra/llmessage/llthrottle.h
@@ -50,7 +50,7 @@ private:
 	F32 mLookaheadSecs;	// Seconds to look ahead, maximum
 	F32	mRate;	// BPS available, dynamically adjusted
 	F32	mAvailable;	// Bits available to send right now on each channel
-	F64	mLastSendTime;		// Time since last send on this channel
+	F64Seconds	mLastSendTime;		// Time since last send on this channel
 };
 
 typedef enum e_throttle_categories
@@ -93,8 +93,8 @@ protected:
 	F32		mBitsSentThisPeriod[TC_EOF];	// Sent in this dynamic allocation period
 	F32		mBitsSentHistory[TC_EOF];		// Sent before this dynamic allocation period, adjusted to one period length
 
-	F64		mLastSendTime[TC_EOF];		// Time since last send on this channel
-	F64		mDynamicAdjustTime;	// Only dynamic adjust every 2 seconds or so.
+	F64Seconds	mLastSendTime[TC_EOF];		// Time since last send on this channel
+	F64Seconds	mDynamicAdjustTime;	// Only dynamic adjust every 2 seconds or so.
 
 };
 
diff --git a/indra/llmessage/lltransfermanager.cpp b/indra/llmessage/lltransfermanager.cpp
index e647df1c11..71be13ab18 100755
--- a/indra/llmessage/lltransfermanager.cpp
+++ b/indra/llmessage/lltransfermanager.cpp
@@ -815,7 +815,7 @@ void LLTransferSourceChannel::updateTransfers()
 		gMessageSystem->addS32("Status", status);
 		gMessageSystem->addBinaryData("Data", datap, data_size);
 		sent_bytes = gMessageSystem->getCurrentSendTotal();
-		gMessageSystem->sendReliable(getHost(), LL_DEFAULT_RELIABLE_RETRIES, TRUE, 0.f,
+		gMessageSystem->sendReliable(getHost(), LL_DEFAULT_RELIABLE_RETRIES, TRUE, F32Seconds(0.f),
 									 LLTransferManager::reliablePacketCallback, (void**)cb_uuid);
 
 		// Do bookkeeping for the throttle
diff --git a/indra/llmessage/message.cpp b/indra/llmessage/message.cpp
index 2b377670f1..1f4dd11f73 100755
--- a/indra/llmessage/message.cpp
+++ b/indra/llmessage/message.cpp
@@ -238,7 +238,7 @@ LLMessageSystem::LLMessageSystem(const std::string& filename, U32 port,
 								 S32 version_patch,
 								 bool failure_is_fatal,
 								 const F32 circuit_heartbeat_interval, const F32 circuit_timeout) :
-	mCircuitInfo(circuit_heartbeat_interval, circuit_timeout),
+	mCircuitInfo(F32Seconds(circuit_heartbeat_interval), F32Seconds(circuit_timeout)),
 	mLastMessageFromTrustedMessageService(false)
 {
 	init();
@@ -303,11 +303,11 @@ LLMessageSystem::LLMessageSystem(const std::string& filename, U32 port,
 	mPollInfop->mPollFD.desc.s = aprSocketp;
 	mPollInfop->mPollFD.client_data = NULL;
 
-	F64 mt_sec = getMessageTimeSeconds();
+	F64Seconds mt_sec = getMessageTimeSeconds();
 	mResendDumpTime = mt_sec;
 	mMessageCountTime = mt_sec;
 	mCircuitPrintTime = mt_sec;
-	mCurrentMessageTimeSeconds = mt_sec;
+	mCurrentMessageTime = F64Seconds(mt_sec);
 
 	// Constants for dumping output based on message processing time/count
 	mNumMessageCounts = 0;
@@ -531,7 +531,7 @@ BOOL LLMessageSystem::checkMessages( S64 frame_count )
 	{
 		// This is the first message being handled after a resetReceiveCounts,
 		// we must be starting the message processing loop.  Reset the timers.
-		mCurrentMessageTimeSeconds = totalTime() * SEC_PER_USEC;
+		mCurrentMessageTime = totalTime();
 		mMessageCountTime = getMessageTimeSeconds();
 	}
 
@@ -758,7 +758,7 @@ BOOL LLMessageSystem::checkMessages( S64 frame_count )
 		}
 	} while (!valid_packet && receive_size > 0);
 
-	F64 mt_sec = getMessageTimeSeconds();
+	F64Seconds mt_sec = getMessageTimeSeconds();
 	// Check to see if we need to print debug info
 	if ((mt_sec - mCircuitPrintTime) > mCircuitPrintFreq)
 	{
@@ -789,7 +789,7 @@ S32	LLMessageSystem::getReceiveBytes() const
 
 void LLMessageSystem::processAcks()
 {
-	F64 mt_sec = getMessageTimeSeconds();
+	F64Seconds mt_sec = getMessageTimeSeconds();
 	{
 		gTransferManager.updateTransfers();
 
@@ -836,7 +836,7 @@ void LLMessageSystem::processAcks()
 		if (mMaxMessageTime >= 0.f)
 		{
 			// This is one of the only places where we're required to get REAL message system time.
-			mReceiveTime = (F32)(getMessageTimeSeconds(TRUE) - mMessageCountTime);
+			mReceiveTime = getMessageTimeSeconds(TRUE) - mMessageCountTime;
 			if (mReceiveTime > mMaxMessageTime)
 			{
 				dump = TRUE;
@@ -1010,13 +1010,13 @@ S32 LLMessageSystem::sendReliable(const LLHost &host)
 
 S32 LLMessageSystem::sendSemiReliable(const LLHost &host, void (*callback)(void **,S32), void ** callback_data)
 {
-	F32 timeout;
+	F32Seconds timeout;
 
 	LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
 	if (cdp)
 	{
 		timeout = llmax(LL_MINIMUM_SEMIRELIABLE_TIMEOUT_SECONDS,
-						LL_SEMIRELIABLE_TIMEOUT_FACTOR * cdp->getPingDelayAveraged());
+						F32Seconds(LL_SEMIRELIABLE_TIMEOUT_FACTOR * cdp->getPingDelayAveraged()));
 	}
 	else
 	{
@@ -1032,7 +1032,7 @@ S32 LLMessageSystem::sendSemiReliable(const LLHost &host, void (*callback)(void
 S32 LLMessageSystem::sendReliable(	const LLHost &host, 
 									S32 retries, 
 									BOOL ping_based_timeout,
-									F32 timeout, 
+									F32Seconds timeout, 
 									void (*callback)(void **,S32), 
 									void ** callback_data)
 {
@@ -1041,11 +1041,11 @@ S32 LLMessageSystem::sendReliable(	const LLHost &host,
 	    LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
 	    if (cdp)
 	    {
-		    timeout = llmax(LL_MINIMUM_RELIABLE_TIMEOUT_SECONDS, LL_RELIABLE_TIMEOUT_FACTOR * cdp->getPingDelayAveraged());
+		    timeout = llmax(LL_MINIMUM_RELIABLE_TIMEOUT_SECONDS, F32Seconds(LL_RELIABLE_TIMEOUT_FACTOR * cdp->getPingDelayAveraged()));
 	    }
 	    else
 	    {
-		    timeout = llmax(LL_MINIMUM_RELIABLE_TIMEOUT_SECONDS, LL_RELIABLE_TIMEOUT_FACTOR * LL_AVERAGED_PING_MAX);
+		    timeout = llmax(LL_MINIMUM_RELIABLE_TIMEOUT_SECONDS, F32Seconds(LL_RELIABLE_TIMEOUT_FACTOR * LL_AVERAGED_PING_MAX));
 	    }
 	}
 
@@ -1077,7 +1077,7 @@ void LLMessageSystem::forwardReliable(const U32 circuit_code)
 S32 LLMessageSystem::forwardReliable(	const LLHost &host, 
 										S32 retries, 
 										BOOL ping_based_timeout,
-										F32 timeout, 
+										F32Seconds timeout, 
 										void (*callback)(void **,S32), 
 										void ** callback_data)
 {
@@ -1087,13 +1087,13 @@ S32 LLMessageSystem::forwardReliable(	const LLHost &host,
 
 S32 LLMessageSystem::flushSemiReliable(const LLHost &host, void (*callback)(void **,S32), void ** callback_data)
 {
-	F32 timeout; 
+	F32Seconds timeout; 
 
 	LLCircuitData *cdp = mCircuitInfo.findCircuit(host);
 	if (cdp)
 	{
 		timeout = llmax(LL_MINIMUM_SEMIRELIABLE_TIMEOUT_SECONDS,
-						LL_SEMIRELIABLE_TIMEOUT_FACTOR * cdp->getPingDelayAveraged());
+						F32Seconds(LL_SEMIRELIABLE_TIMEOUT_FACTOR * cdp->getPingDelayAveraged()));
 	}
 	else
 	{
@@ -3389,15 +3389,15 @@ void LLMessageSystem::dumpPacketToLog()
 
 
 //static
-U64 LLMessageSystem::getMessageTimeUsecs(const BOOL update)
+U64Microseconds LLMessageSystem::getMessageTimeUsecs(const BOOL update)
 {
 	if (gMessageSystem)
 	{
 		if (update)
 		{
-			gMessageSystem->mCurrentMessageTimeSeconds = totalTime()*SEC_PER_USEC;
+			gMessageSystem->mCurrentMessageTime = totalTime();
 		}
-		return (U64)(gMessageSystem->mCurrentMessageTimeSeconds * USEC_PER_SEC);
+		return gMessageSystem->mCurrentMessageTime;
 	}
 	else
 	{
@@ -3406,19 +3406,19 @@ U64 LLMessageSystem::getMessageTimeUsecs(const BOOL update)
 }
 
 //static
-F64 LLMessageSystem::getMessageTimeSeconds(const BOOL update)
+F64Seconds LLMessageSystem::getMessageTimeSeconds(const BOOL update)
 {
 	if (gMessageSystem)
 	{
 		if (update)
 		{
-			gMessageSystem->mCurrentMessageTimeSeconds = totalTime()*SEC_PER_USEC;
+			gMessageSystem->mCurrentMessageTime = totalTime();
 		}
-		return gMessageSystem->mCurrentMessageTimeSeconds;
+		return gMessageSystem->mCurrentMessageTime;
 	}
 	else
 	{
-		return totalTime()*SEC_PER_USEC;
+		return F64Seconds(totalTime());
 	}
 }
 
diff --git a/indra/llmessage/message.h b/indra/llmessage/message.h
index af0eb109e3..75eccc7f75 100755
--- a/indra/llmessage/message.h
+++ b/indra/llmessage/message.h
@@ -142,18 +142,14 @@ enum EPacketHeaderLayout
 
 
 const S32 LL_DEFAULT_RELIABLE_RETRIES = 3;
-const F32 LL_MINIMUM_RELIABLE_TIMEOUT_SECONDS = 1.f;
-const F32 LL_MINIMUM_SEMIRELIABLE_TIMEOUT_SECONDS = 1.f;
-const F32 LL_PING_BASED_TIMEOUT_DUMMY = 0.0f;
-
-// *NOTE: Maybe these factors shouldn't include the msec to sec conversion
-// implicitly.
-// However, all units should be MKS.
-const F32 LL_SEMIRELIABLE_TIMEOUT_FACTOR	= 5.f / 1000.f;		// factor * averaged ping
-const F32 LL_RELIABLE_TIMEOUT_FACTOR		= 5.f / 1000.f;      // factor * averaged ping
-const F32 LL_FILE_XFER_TIMEOUT_FACTOR		= 5.f / 1000.f;      // factor * averaged ping
-const F32 LL_LOST_TIMEOUT_FACTOR			= 16.f / 1000.f;     // factor * averaged ping for marking packets "Lost"
-const F32 LL_MAX_LOST_TIMEOUT				= 5.f;				// Maximum amount of time before considering something "lost"
+const F32Seconds LL_MINIMUM_RELIABLE_TIMEOUT_SECONDS(1.f);
+const F32Seconds LL_MINIMUM_SEMIRELIABLE_TIMEOUT_SECONDS(1.f);
+const F32Seconds LL_PING_BASED_TIMEOUT_DUMMY(0.0f);
+
+const F32 LL_SEMIRELIABLE_TIMEOUT_FACTOR	= 5.f;		// averaged ping
+const F32 LL_RELIABLE_TIMEOUT_FACTOR		= 5.f;		// averaged ping
+const F32 LL_LOST_TIMEOUT_FACTOR			= 16.f;     // averaged ping for marking packets "Lost"
+const F32Seconds LL_MAX_LOST_TIMEOUT(5.f);				// Maximum amount of time before considering something "lost"
 
 const S32 MAX_MESSAGE_COUNT_NUM = 1024;
 
@@ -270,7 +266,7 @@ public:
 	BOOL                mSendReliable;              // does the outgoing message require a pos ack?
 
 	LLCircuit 	 		mCircuitInfo;
-	F64					mCircuitPrintTime;	    // used to print circuit debug info every couple minutes
+	F64Seconds			mCircuitPrintTime;	    // used to print circuit debug info every couple minutes
 	F32					mCircuitPrintFreq;	    // seconds
 
 	std::map<U64, U32>	mIPPortToCircuitCode;
@@ -469,7 +465,7 @@ public:
 	S32	sendReliable(	const LLHost &host, 
 							S32 retries, 
 							BOOL ping_based_retries,
-							F32 timeout, 
+							F32Seconds timeout, 
 							void (*callback)(void **,S32), 
 							void ** callback_data);
 
@@ -489,7 +485,7 @@ public:
 		const LLHost &host, 
 		S32 retries, 
 		BOOL ping_based_timeout,
-		F32 timeout, 
+		F32Seconds timeout, 
 		void (*callback)(void **,S32), 
 		void ** callback_data);
 
@@ -683,8 +679,8 @@ public:
 	void setMaxMessageTime(const F32 seconds);	// Max time to process messages before warning and dumping (neg to disable)
 	void setMaxMessageCounts(const S32 num);	// Max number of messages before dumping (neg to disable)
 	
-	static U64 getMessageTimeUsecs(const BOOL update = FALSE);	// Get the current message system time in microseconds
-	static F64 getMessageTimeSeconds(const BOOL update = FALSE); // Get the current message system time in seconds
+	static U64Microseconds getMessageTimeUsecs(const BOOL update = FALSE);	// Get the current message system time in microseconds
+	static F64Seconds getMessageTimeSeconds(const BOOL update = FALSE); // Get the current message system time in seconds
 
 	static void setTimeDecodes(BOOL b);
 	static void setTimeDecodesSpamThreshold(F32 seconds); 
@@ -783,16 +779,16 @@ private:
 	BOOL	mbError;
 	S32	mErrorCode;
 
-	F64										mResendDumpTime; // The last time we dumped resends
+	F64Seconds										mResendDumpTime; // The last time we dumped resends
 
 	LLMessageCountInfo mMessageCountList[MAX_MESSAGE_COUNT_NUM];
 	S32 mNumMessageCounts;
-	F32 mReceiveTime;
-	F32 mMaxMessageTime; // Max number of seconds for processing messages
+	F32Seconds mReceiveTime;
+	F32Seconds mMaxMessageTime; // Max number of seconds for processing messages
 	S32 mMaxMessageCounts; // Max number of messages to process before dumping.
-	F64 mMessageCountTime;
+	F64Seconds mMessageCountTime;
 
-	F64 mCurrentMessageTimeSeconds; // The current "message system time" (updated the first call to checkMessages after a resetReceiveCount
+	F64Seconds mCurrentMessageTime; // The current "message system time" (updated the first call to checkMessages after a resetReceiveCount
 
 	// message system exceptions
 	typedef std::pair<msg_exception_callback, void*> exception_t;