SH-4090 Integrating deadman timer with mesh repo downloads.

Timer interface violated my design rules and I paid for it
with clumsiness and silent errors.  Cleaned it up mainly
removing the evil default values.  Found better integration
points in the mesh downloader and it's producing fairly
consistent numbers on the MeshTest2 test region (about
5500 downloads, ~90 seconds, +/- 10 seconds).  Will review
with davep and do an early timer stop on teleport which
invalidates a timing sequence.

5 files changed, 174 insertions, 104 deletions

diff --git a/indra/llcommon/lldeadmantimer.cpp b/indra/llcommon/lldeadmantimer.cpp
index 3d3f738c06..2a356d857a 100644
--- a/indra/llcommon/lldeadmantimer.cpp
+++ b/indra/llcommon/lldeadmantimer.cpp
@@ -43,7 +43,7 @@
 //    true    true   Not allowed
 //
 LLDeadmanTimer::LLDeadmanTimer(F64 horizon)
-	: mHorizon(U64(llmax(horizon, F64(0.0)) * gClockFrequency)),
+	: mHorizon(time_type(llmax(horizon, F64(0.0)) * gClockFrequency)),
 	  mActive(false),			// If true, a timer is running.
 	  mDone(false),				// If true, timer has completed and can be read (once)
 	  mStarted(U64L(0)),
@@ -53,7 +53,14 @@ LLDeadmanTimer::LLDeadmanTimer(F64 horizon)
 {}
 
 
-void LLDeadmanTimer::start(U64 now)
+// static
+LLDeadmanTimer::time_type LLDeadmanTimer::getNow()
+{
+	return LLTimer::getCurrentClockCount();
+}
+
+
+void LLDeadmanTimer::start(time_type now)
 {
 	// *TODO:  If active, let's complete an existing timer and save
 	// the result to the side.  I think this will be useful later.
@@ -72,7 +79,7 @@ void LLDeadmanTimer::start(U64 now)
 }
 
 
-void LLDeadmanTimer::stop(U64 now)
+void LLDeadmanTimer::stop(time_type now)
 {
 	if (! mActive)
 	{
@@ -81,7 +88,7 @@ void LLDeadmanTimer::stop(U64 now)
 
 	if (! now)
 	{
-		now = LLTimer::getCurrentClockCount();
+		now = getNow();
 	}
 	mStopped = now;
 	mActive = false;
@@ -89,13 +96,13 @@ void LLDeadmanTimer::stop(U64 now)
 }
 
 
-bool LLDeadmanTimer::isExpired(F64 & started, F64 & stopped, U64 & count, U64 now)
+bool LLDeadmanTimer::isExpired(time_type now, F64 & started, F64 & stopped, U64 & count)
 {
 	if (mActive && ! mDone)
 	{
 		if (! now)
 		{
-			now = LLTimer::getCurrentClockCount();
+			now = getNow();
 		}
 
 		if (now >= mExpires)
@@ -120,7 +127,7 @@ bool LLDeadmanTimer::isExpired(F64 & started, F64 & stopped, U64 & count, U64 no
 }
 
 	
-void LLDeadmanTimer::ringBell(U64 now)
+void LLDeadmanTimer::ringBell(time_type now, unsigned int count)
 {
 	if (! mActive)
 	{
@@ -129,7 +136,7 @@ void LLDeadmanTimer::ringBell(U64 now)
 	
 	if (! now)
 	{
-		now = LLTimer::getCurrentClockCount();
+		now = getNow();
 	}
 
 	if (now >= mExpires)
@@ -141,7 +148,7 @@ void LLDeadmanTimer::ringBell(U64 now)
 	{
 		mStopped = now;
 		mExpires = now + mHorizon;
-		++mCount;
+		mCount += count;
 	}
 	
 	return;
diff --git a/indra/llcommon/lldeadmantimer.h b/indra/llcommon/lldeadmantimer.h
index 84023723ab..8643b8cad8 100644
--- a/indra/llcommon/lldeadmantimer.h
+++ b/indra/llcommon/lldeadmantimer.h
@@ -77,6 +77,16 @@
 class LL_COMMON_API LLDeadmanTimer
 {
 public:
+	/// Public types
+
+	/// Low-level time type chosen for compatibility with
+	/// LLTimer::getCurrentClockCount() which is the basis
+	/// of time operations in this class.  This is likely
+	/// to change in a future version in a move to TSC-based
+	/// timing.
+	typedef U64 time_type;
+	
+public:
 	/// Construct and initialize an LLDeadmanTimer
 	///
 	/// @param horizon	Time, in seconds, after the last @see ringBell()
@@ -93,6 +103,18 @@ private:
 	void operator=(const LLDeadmanTimer &);				// Not defined
 
 public:
+	/// Get the current time.  Zero-basis for this time
+	/// representation is not defined and is different on
+	/// different platforms.  Do not attempt to compute
+	/// negative times relative to the first value returned,
+	/// there may not be enough 'front porch' on the range
+	/// to prevent wraparound.
+	///
+	/// Note:  Implementation is expected to change in a
+	/// future release as well.
+	///
+	static time_type getNow();
+
 	/// Begin timing.  If the timer is already active, it is reset
 	///	and timing begins now.
 	///
@@ -100,8 +122,7 @@ public:
 	///					LLTimer::getCurrentClockCount().  If zero,
 	///					method will lookup current time.
 	///
-	void start(U64 now = U64L(0));
-
+	void start(time_type now);
 
 	/// End timing.  Actively declare the end of the event independent
 	/// of the deadman's switch operation.  @see isExpired() will return
@@ -111,28 +132,34 @@ public:
 	///					LLTimer::getCurrentClockCount().  If zero,
 	///					method will lookup current time.
 	///
-	void stop(U64 now = U64L(0));
-
+	void stop(time_type now);
 
 	/// Declare that something interesting happened.  This has two
 	/// effects on an unexpired-timer.  1)  The expiration time
 	/// is extended for 'horizon' seconds after the 'now' value.
-	/// 2)  An internal counter associated with the event is incremented.
-	/// This count is returned via the @see isExpired() method.
+	/// 2)  An internal counter associated with the event is incremented
+	/// by the @ref count parameter.  This count is returned via the
+	/// @see isExpired() method.
 	///
 	/// @param now		Current time as returned by @see
 	///					LLTimer::getCurrentClockCount().  If zero,
 	///					method will lookup current time.
 	///
-	void ringBell(U64 now = U64L(0));
+	/// @param count	Count of events to be associated with
+	///					this bell ringing.
+	///
+	void ringBell(time_type now, unsigned int count);
 	
-
 	/// Checks on the status of the timer Declare that something interesting happened.  This has two
 	/// effects on an unexpired-timer.  1)  The expiration time
 	/// is extended for 'horizon' seconds after the 'now' value.
 	/// 2)  An internal counter associated with the event is incremented.
 	/// This count is returned via the @see isExpired() method.
 	///
+	/// @param now		Current time as returned by @see
+	///					LLTimer::getCurrentClockCount().  If zero,
+	///					method will lookup current time.
+	///
 	/// @param started	If expired, the starting time of the event is
 	///					returned to the caller via this reference.
 	///
@@ -146,25 +173,21 @@ public:
 	/// @param count	If expired, the number of ringBell() calls
 	///					made prior to expiration.
 	///
-	/// @param now		Current time as returned by @see
-	///					LLTimer::getCurrentClockCount().  If zero,
-	///					method will lookup current time.
-	///
 	/// @return			true if the timer has expired, false otherwise.
 	///					If true, it also returns the started,
 	///					stopped and count values otherwise these are
 	///					left unchanged.
 	///
-	bool isExpired(F64 & started, F64 & stopped, U64 & count, U64 now = U64L(0));
+	bool isExpired(time_type now, F64 & started, F64 & stopped, U64 & count);
 
 protected:
-	U64			mHorizon;
+	time_type	mHorizon;
 	bool		mActive;
 	bool		mDone;
-	U64			mStarted;
-	U64			mExpires;
-	U64			mStopped;
-	U64			mCount;
+	time_type	mStarted;
+	time_type	mExpires;
+	time_type	mStopped;
+	time_type	mCount;
 };
 	
 
diff --git a/indra/llcommon/tests/lldeadmantimer_test.cpp b/indra/llcommon/tests/lldeadmantimer_test.cpp
index 40e354115b..63cab29e04 100644
--- a/indra/llcommon/tests/lldeadmantimer_test.cpp
+++ b/indra/llcommon/tests/lldeadmantimer_test.cpp
@@ -34,12 +34,12 @@
 // Convert between floating point time deltas and U64 time deltas.
 // Reflects an implementation detail inside lldeadmantimer.cpp
 
-static U64 float_time_to_u64(F64 delta)
+static LLDeadmanTimer::time_type float_time_to_u64(F64 delta)
 {
-	return U64(delta * gClockFrequency);
+	return LLDeadmanTimer::time_type(delta * gClockFrequency);
 }
 
-static F64 u64_time_to_float(U64 delta)
+static F64 u64_time_to_float(LLDeadmanTimer::time_type delta)
 {
 	return delta * gClockFrequencyInv;
 }
@@ -69,7 +69,7 @@ void deadmantimer_object_t::test<1>()
 	U64 count(U64L(8));
 	LLDeadmanTimer timer(10.0);
 
-	ensure_equals("isExpired() returns false after ctor()", timer.isExpired(started, stopped, count), false);
+	ensure_equals("isExpired() returns false after ctor()", timer.isExpired(0, started, stopped, count), false);
 	ensure_approximately_equals("t1 - isExpired() does not modify started", started, F64(42.0), 2);
 	ensure_approximately_equals("t1 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
 	ensure_equals("t1 - isExpired() does not modify count", count, U64L(8));
@@ -84,7 +84,8 @@ void deadmantimer_object_t::test<2>()
 	U64 count(U64L(8));
 	LLDeadmanTimer timer(0.0);			// Zero is pre-expired
 
-	ensure_equals("isExpired() still returns false with 0.0 time ctor()", timer.isExpired(started, stopped, count), false);
+	ensure_equals("isExpired() still returns false with 0.0 time ctor()",
+				  timer.isExpired(0, started, stopped, count), false);
 }
 
 
@@ -97,8 +98,9 @@ void deadmantimer_object_t::test<3>()
 	U64 count(U64L(8));
 	LLDeadmanTimer timer(0.0);
 
-	timer.start();
-	ensure_equals("isExpired() returns true with 0.0 horizon time", timer.isExpired(started, stopped, count), true);
+	timer.start(0);
+	ensure_equals("isExpired() returns true with 0.0 horizon time",
+				  timer.isExpired(0, started, stopped, count), true);
 	ensure_approximately_equals("expired timer with no bell ringing has stopped == started", started, stopped, 8);
 }
 
@@ -111,14 +113,15 @@ void deadmantimer_object_t::test<4>()
 	U64 count(U64L(8));
 	LLDeadmanTimer timer(0.0);
 	
-	timer.start();
-	timer.ringBell(LLTimer::getCurrentClockCount() + float_time_to_u64(1000.0));
-	ensure_equals("isExpired() returns true with 0.0 horizon time after bell ring", timer.isExpired(started, stopped, count), true);
+	timer.start(0);
+	timer.ringBell(LLDeadmanTimer::getNow() + float_time_to_u64(1000.0), 1);
+	ensure_equals("isExpired() returns true with 0.0 horizon time after bell ring",
+				  timer.isExpired(0, started, stopped, count), true);
 	ensure_approximately_equals("ringBell has no impact on expired timer leaving stopped == started", started, stopped, 8);
 }
 
 
-// start() test - unexpired timer reports unexpired
+// start(0) test - unexpired timer reports unexpired
 template<> template<>
 void deadmantimer_object_t::test<5>()
 {
@@ -126,8 +129,9 @@ void deadmantimer_object_t::test<5>()
 	U64 count(U64L(8));
 	LLDeadmanTimer timer(10.0);
 	
-	timer.start();
-	ensure_equals("isExpired() returns false after starting with 10.0 horizon time", timer.isExpired(started, stopped, count), false);
+	timer.start(0);
+	ensure_equals("isExpired() returns false after starting with 10.0 horizon time",
+				  timer.isExpired(0, started, stopped, count), false);
 	ensure_approximately_equals("t5 - isExpired() does not modify started", started, F64(42.0), 2);
 	ensure_approximately_equals("t5 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
 	ensure_equals("t5 - isExpired() does not modify count", count, U64L(8));
@@ -146,10 +150,11 @@ void deadmantimer_object_t::test<6>()
 	// the implementation on Windows is zero-based.  We wrap around
 	// the backside resulting in a large U64 number.
 	
-	U64 the_past(LLTimer::getCurrentClockCount());
-	U64 now(the_past + float_time_to_u64(5.0));
+	LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
+	LLDeadmanTimer::time_type now(the_past + float_time_to_u64(5.0));
 	timer.start(the_past);
-	ensure_equals("isExpired() returns false with 10.0 horizon time starting 5.0 in past", timer.isExpired(started, stopped, count, now), false);
+	ensure_equals("isExpired() returns false with 10.0 horizon time starting 5.0 in past",
+				  timer.isExpired(now, started, stopped, count), false);
 	ensure_approximately_equals("t6 - isExpired() does not modify started", started, F64(42.0), 2);
 	ensure_approximately_equals("t6 - isExpired() does not modify stopped", stopped, F64(97.0), 2);
 	ensure_equals("t6 - isExpired() does not modify count", count, U64L(8));
@@ -168,10 +173,11 @@ void deadmantimer_object_t::test<7>()
 	// the implementation on Windows is zero-based.  We wrap around
 	// the backside resulting in a large U64 number.
 	
-	U64 the_past(LLTimer::getCurrentClockCount());
-	U64 now(the_past + float_time_to_u64(20.0));
+	LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
+	LLDeadmanTimer::time_type now(the_past + float_time_to_u64(20.0));
 	timer.start(the_past);
-	ensure_equals("isExpired() returns true with 10.0 horizon time starting 20.0 in past", timer.isExpired(started, stopped, count, now), true);
+	ensure_equals("isExpired() returns true with 10.0 horizon time starting 20.0 in past",
+				  timer.isExpired(now,started, stopped, count), true);
 	ensure_approximately_equals("starting before horizon still gives equal started / stopped", started, stopped, 8);
 }
 
@@ -188,15 +194,17 @@ void deadmantimer_object_t::test<8>()
 	// the implementation on Windows is zero-based.  We wrap around
 	// the backside resulting in a large U64 number.
 	
-	U64 the_past(LLTimer::getCurrentClockCount());
-	U64 now(the_past + float_time_to_u64(20.0));
+	LLDeadmanTimer::time_type the_past(LLDeadmanTimer::getNow());
+	LLDeadmanTimer::time_type now(the_past + float_time_to_u64(20.0));
 	timer.start(the_past);
-	ensure_equals("t8 - isExpired() returns true with 10.0 horizon time starting 20.0 in past", timer.isExpired(started, stopped, count, now), true);
+	ensure_equals("t8 - isExpired() returns true with 10.0 horizon time starting 20.0 in past",
+				  timer.isExpired(now, started, stopped, count), true);
 
 	started = 42.0;
 	stopped = 97.0;
 	count = U64L(8);
-	ensure_equals("t8 - second isExpired() returns false after true", timer.isExpired(started, stopped, count, now), false);
+	ensure_equals("t8 - second isExpired() returns false after true",
+				  timer.isExpired(now, started, stopped, count), false);
 	ensure_approximately_equals("t8 - 2nd isExpired() does not modify started", started, F64(42.0), 2);
 	ensure_approximately_equals("t8 - 2nd isExpired() does not modify stopped", stopped, F64(97.0), 2);
 	ensure_equals("t8 - 2nd isExpired() does not modify count", count, U64L(8));
@@ -211,40 +219,42 @@ void deadmantimer_object_t::test<9>()
 	U64 count(U64L(8));
 	LLDeadmanTimer timer(5.0);
 
-	U64 now(LLTimer::getCurrentClockCount());
+	LLDeadmanTimer::time_type now(LLDeadmanTimer::getNow());
 	F64 real_start(u64_time_to_float(now));
-	timer.start();
+	timer.start(0);
 
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
-	ensure_equals("t9 - 5.0 horizon timer has not timed out after 10 1-second bell rings", timer.isExpired(started, stopped, count, now), false);
+	timer.ringBell(now, 1);
+	ensure_equals("t9 - 5.0 horizon timer has not timed out after 10 1-second bell rings",
+				  timer.isExpired(now, started, stopped, count), false);
 	F64 last_good_ring(u64_time_to_float(now));
 
 	// Jump forward and expire
 	now += float_time_to_u64(10.0);
-	ensure_equals("t9 - 5.0 horizon timer expires on 10-second jump", timer.isExpired(started, stopped, count, now), true);
+	ensure_equals("t9 - 5.0 horizon timer expires on 10-second jump",
+				  timer.isExpired(now, started, stopped, count), true);
 	ensure_approximately_equals("t9 - started matches start() time", started, real_start, 4);
 	ensure_approximately_equals("t9 - stopped matches last ringBell() time", stopped, last_good_ring, 4);
 	ensure_equals("t9 - 10 good ringBell()s", count, U64L(10));
-	ensure_equals("t9 - single read only", timer.isExpired(started, stopped, count, now), false);
+	ensure_equals("t9 - single read only", timer.isExpired(now, started, stopped, count), false);
 }
 
 
@@ -256,40 +266,42 @@ void deadmantimer_object_t::test<10>()
 	U64 count(U64L(8));
 	LLDeadmanTimer timer(5.0);
 
-	U64 now(LLTimer::getCurrentClockCount());
+	LLDeadmanTimer::time_type now(LLDeadmanTimer::getNow());
 	F64 real_start(u64_time_to_float(now));
-	timer.start();
+	timer.start(0);
 
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
-	ensure_equals("t10 - 5.0 horizon timer has not timed out after 10 1-second bell rings", timer.isExpired(started, stopped, count, now), false);
+	timer.ringBell(now, 1);
+	ensure_equals("t10 - 5.0 horizon timer has not timed out after 10 1-second bell rings",
+				  timer.isExpired(now, started, stopped, count), false);
 	F64 last_good_ring(u64_time_to_float(now));
 
 	// Jump forward and expire
 	now += float_time_to_u64(10.0);
-	ensure_equals("t10 - 5.0 horizon timer expires on 10-second jump", timer.isExpired(started, stopped, count, now), true);
+	ensure_equals("t10 - 5.0 horizon timer expires on 10-second jump",
+				  timer.isExpired(now, started, stopped, count), true);
 	ensure_approximately_equals("t10 - started matches start() time", started, real_start, 4);
 	ensure_approximately_equals("t10 - stopped matches last ringBell() time", stopped, last_good_ring, 4);
 	ensure_equals("t10 - 10 good ringBell()s", count, U64L(10));
-	ensure_equals("t10 - single read only", timer.isExpired(started, stopped, count, now), false);
+	ensure_equals("t10 - single read only", timer.isExpired(now, started, stopped, count), false);
 
 	// Jump forward and restart
 	now += float_time_to_u64(1.0);
@@ -298,31 +310,34 @@ void deadmantimer_object_t::test<10>()
 
 	// Run a modified bell ring sequence
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
+	timer.ringBell(now, 1);
 	now += float_time_to_u64(1.0);
-	timer.ringBell(now);
-	ensure_equals("t10 - 5.0 horizon timer has not timed out after 8 1-second bell rings", timer.isExpired(started, stopped, count, now), false);
+	timer.ringBell(now, 1);
+	ensure_equals("t10 - 5.0 horizon timer has not timed out after 8 1-second bell rings",
+				  timer.isExpired(now, started, stopped, count), false);
 	last_good_ring = u64_time_to_float(now);
 
 	// Jump forward and expire
 	now += float_time_to_u64(10.0);
-	ensure_equals("t10 - 5.0 horizon timer expires on 8-second jump", timer.isExpired(started, stopped, count, now), true);
+	ensure_equals("t10 - 5.0 horizon timer expires on 8-second jump",
+				  timer.isExpired(now, started, stopped, count), true);
 	ensure_approximately_equals("t10 - 2nd started matches start() time", started, real_start, 4);
 	ensure_approximately_equals("t10 - 2nd stopped matches last ringBell() time", stopped, last_good_ring, 4);
 	ensure_equals("t10 - 8 good ringBell()s", count, U64L(8));
-	ensure_equals("t10 - single read only - 2nd start", timer.isExpired(started, stopped, count, now), false);
+	ensure_equals("t10 - single read only - 2nd start",
+				  timer.isExpired(now, started, stopped, count), false);
 }
 
 
diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index 11c5780a30..8f97f3e71a 100755
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -2168,6 +2168,9 @@ void LLMeshHeaderResponder::completedRaw(U32 status, const std::string& reason,
 
 	if (status < 200 || status > 400)
 	{
+		// Manage time-to-load metrics for mesh download operations.
+		LLMeshRepository::metricsProgress(0);
+
 		//llwarns
 		//	<< "Header responder failed with status: "
 		//	<< status << ": " << reason << llendl;
@@ -2358,6 +2361,9 @@ void LLMeshRepository::shutdown()
 //called in the main thread.
 S32 LLMeshRepository::update()
 {
+	// Conditionally log a mesh metrics event
+	metricsUpdate();
+	
 	if(mUploadWaitList.empty())
 	{
 		return 0 ;
@@ -2377,6 +2383,9 @@ S32 LLMeshRepository::update()
 
 S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_params, S32 detail, S32 last_lod)
 {
+	// Manage time-to-load metrics for mesh download operations.
+	metricsProgress(1);
+
 	if (detail < 0 || detail > 4)
 	{
 		return detail;
@@ -2680,7 +2689,7 @@ void LLMeshRepository::notifyDecompositionReceived(LLModel::Decomposition* decom
 void LLMeshRepository::notifyMeshLoaded(const LLVolumeParams& mesh_params, LLVolume* volume)
 { //called from main thread
 	// Manage time-to-load metrics for mesh download operations.
-	metricsCheck();
+	metricsProgress(0);
 	
 	S32 detail = LLVolumeLODGroup::getVolumeDetailFromScale(volume->getDetail());
 
@@ -2725,6 +2734,9 @@ void LLMeshRepository::notifyMeshLoaded(const LLVolumeParams& mesh_params, LLVol
 
 void LLMeshRepository::notifyMeshUnavailable(const LLVolumeParams& mesh_params, S32 lod)
 { //called from main thread
+	// Manage time-to-load metrics for mesh download operations.
+	metricsProgress(0);
+	
 	//get list of objects waiting to be notified this mesh is loaded
 	mesh_load_map::iterator obj_iter = mLoadingMeshes[lod].find(mesh_params);
 
@@ -3704,39 +3716,51 @@ bool LLMeshRepository::meshRezEnabled()
 	return false;
 }
 
+// Threading:  main thread only
+// static
 void LLMeshRepository::metricsStart()
 {
-	sQuiescentTimer.start();
+	sQuiescentTimer.start(0);
 }
 
+// Threading:  main thread only
+// static
 void LLMeshRepository::metricsStop()
 {
-	sQuiescentTimer.stop();
+	sQuiescentTimer.stop(0);
 }
 
-void LLMeshRepository::metricsCheck()
+// Threading:  main thread only
+// static
+void LLMeshRepository::metricsProgress(unsigned int this_count)
 {
 	static bool first_start(true);
-	F64 started, stopped;
-	U64 count;
-
 	if (first_start)
 	{
 		// Let the first request start the timing cycle for login.
 		metricsStart();
 		first_start = false;
 	}
-	sQuiescentTimer.ringBell();
-	if (sQuiescentTimer.isExpired(started, stopped, count))
+	sQuiescentTimer.ringBell(0, this_count);
+}
+
+// Threading:  main thread only
+// static
+void LLMeshRepository::metricsUpdate()
+{
+	F64 started, stopped;
+	U64 total_count;
+
+	if (sQuiescentTimer.isExpired(0, started, stopped, total_count))
 	{
 		LLSD metrics;
 
-		metrics["reason"] = "Mesh download quiescent";
+		metrics["reason"] = "Mesh Download Quiescent";
 		metrics["scope"] = "Login";
 		metrics["start"] = started;
 		metrics["stop"] = stopped;
-		metrics["downloads"] = LLSD::Integer(count);
-		llinfos << "MetricsMarker" << metrics << llendl;
+		metrics["downloads"] = LLSD::Integer(total_count);
+		llinfos << "EventMarker " << metrics << llendl;
 	}
 }
 	
diff --git a/indra/newview/llmeshrepository.h b/indra/newview/llmeshrepository.h
index f08feedf81..3cdc66e1f0 100644
--- a/indra/newview/llmeshrepository.h
+++ b/indra/newview/llmeshrepository.h
@@ -500,7 +500,8 @@ public:
 	// Quiescent timer management, main thread only.
 	static void metricsStart();
 	static void metricsStop();
-	static void metricsCheck();
+	static void metricsProgress(unsigned int count);
+	static void metricsUpdate();
 	
 	typedef std::map<LLVolumeParams, std::set<LLUUID> > mesh_load_map;
 	mesh_load_map mLoadingMeshes[4];