21 files changed, 743 insertions, 152 deletions

diff --git a/linden/indra/llcommon/CMakeLists.txt b/linden/indra/llcommon/CMakeLists.txt
index 8810549..4001e1f 100644
--- a/linden/indra/llcommon/CMakeLists.txt
+++ b/linden/indra/llcommon/CMakeLists.txt
@@ -187,3 +187,10 @@ set_source_files_properties(${llcommon_HEADER_FILES}
 list(APPEND llcommon_SOURCE_FILES ${llcommon_HEADER_FILES})
 
 add_library (llcommon ${llcommon_SOURCE_FILES})
+target_link_libraries(
+    llcommon
+    ${APRUTIL_LIBRARIES}
+    ${APR_LIBRARIES}
+    ${EXPAT_LIBRARIES}
+    ${ZLIB_LIBRARIES}
+    )
diff --git a/linden/indra/llcommon/indra_constants.h b/linden/indra/llcommon/indra_constants.h
index 1c48a5c..fcb2aaf 100644
--- a/linden/indra/llcommon/indra_constants.h
+++ b/linden/indra/llcommon/indra_constants.h
@@ -251,6 +251,7 @@ const U8 GOD_NOT = 0;
 const LLUUID LL_UUID_ALL_AGENTS("44e87126-e794-4ded-05b3-7c42da3d5cdb");
 
 // Governor Linden's agent id.
+const LLUUID ALEXANDRIA_LINDEN_ID("ba2a564a-f0f1-4b82-9c61-b7520bfcd09f");
 const LLUUID GOVERNOR_LINDEN_ID("3d6181b0-6a4b-97ef-18d8-722652995cf1");
 const LLUUID REALESTATE_LINDEN_ID("3d6181b0-6a4b-97ef-18d8-722652995cf1");
 // Maintenance's group id.
diff --git a/linden/indra/llcommon/llcommon.cpp b/linden/indra/llcommon/llcommon.cpp
index b21b687..cdaa7f9 100644
--- a/linden/indra/llcommon/llcommon.cpp
+++ b/linden/indra/llcommon/llcommon.cpp
@@ -46,7 +46,7 @@ void LLCommon::initClass()
                 sAprInitialized = TRUE;
         }
         LLTimer::initClass();
-        LLThreadSafeRefCount::initClass();
+        LLThreadSafeRefCount::initThreadSafeRefCount();
 //      LLWorkerThread::initClass();
 //      LLFrameCallbackManager::initClass();
 }
@@ -56,7 +56,7 @@ void LLCommon::cleanupClass()
 {
 //      LLFrameCallbackManager::cleanupClass();
 //      LLWorkerThread::cleanupClass();
-        LLThreadSafeRefCount::cleanupClass();
+        LLThreadSafeRefCount::cleanupThreadSafeRefCount();
         LLTimer::cleanupClass();
         if (sAprInitialized)
         {
diff --git a/linden/indra/llcommon/llfasttimer.h b/linden/indra/llcommon/llfasttimer.h
index 8ad2667..80ed26b 100644
--- a/linden/indra/llcommon/llfasttimer.h
+++ b/linden/indra/llcommon/llfasttimer.h
@@ -165,6 +165,7 @@ public:
                 FTM_FILTER,
                 FTM_REFRESH,
                 FTM_SORT,
+                FTM_PICK,
                 
                 // Temp
                 FTM_TEMP1,
diff --git a/linden/indra/llcommon/llfindlocale.cpp b/linden/indra/llcommon/llfindlocale.cpp
index 47da974..344041c 100644
--- a/linden/indra/llcommon/llfindlocale.cpp
+++ b/linden/indra/llcommon/llfindlocale.cpp
@@ -180,10 +180,10 @@ canonise_fl(FL_Locale *l) {
 #define ML(pn,sn) MAKELANGID(LANG_##pn, SUBLANG_##pn##_##sn)
 #define MLN(pn) MAKELANGID(LANG_##pn, SUBLANG_DEFAULT)
 #define RML(pn,sn) MAKELANGID(LANG_##pn, SUBLANG_##sn)
-typedef struct {
+struct IDToCode {
   LANGID id;
   char*  code;
-} IDToCode;
+};
 static const IDToCode both_to_code[] = {
   {ML(ENGLISH,US),           "en_US.ISO_8859-1"},
   {ML(ENGLISH,CAN),          "en_CA"}, /* english / canadian */
diff --git a/linden/indra/llcommon/llfindlocale.h b/linden/indra/llcommon/llfindlocale.h
index 6cc2dbb..bc253c3 100644
--- a/linden/indra/llcommon/llfindlocale.h
+++ b/linden/indra/llcommon/llfindlocale.h
@@ -36,11 +36,11 @@ typedef const char* FL_Lang;
 typedef const char* FL_Country;
 typedef const char* FL_Variant;
 
-typedef struct {
+struct FL_Locale {
   FL_Lang    lang;
   FL_Country country;
   FL_Variant variant;
-} FL_Locale;
+};
 
 typedef enum {
   /* for some reason we failed to even guess: this should never happen */
diff --git a/linden/indra/llcommon/llkeythrottle.h b/linden/indra/llcommon/llkeythrottle.h
index eb1519a..25d0fe0 100644
--- a/linden/indra/llcommon/llkeythrottle.h
+++ b/linden/indra/llcommon/llkeythrottle.h
@@ -243,7 +243,7 @@ public:
         }
 
         // Set the throttling behavior
-        void setParameters( U32 limit, F32 interval, BOOL realtime )
+        void setParameters( U32 limit, F32 interval, BOOL realtime = TRUE )
         {
                 // limit is the maximum number of keys
                 // allowed per interval (in seconds or frames)
diff --git a/linden/indra/llcommon/llprocessor.h b/linden/indra/llcommon/llprocessor.h
index 6abbd96..06dc72a 100644
--- a/linden/indra/llcommon/llprocessor.h
+++ b/linden/indra/llcommon/llprocessor.h
@@ -58,7 +58,7 @@
 #endif
 
 
-typedef struct ProcessorExtensions
+struct ProcessorExtensions
 {
         bool FPU_FloatingPointUnit;
         bool VME_Virtual8086ModeEnhancements;
@@ -97,9 +97,9 @@ typedef struct ProcessorExtensions
         bool _3DNOW_InstructionExtensions;
         bool _E3DNOW_InstructionExtensions;
         bool AA64_AMD64BitArchitecture;
-} ProcessorExtensions;
+};
 
-typedef struct ProcessorCache
+struct ProcessorCache
 {
         bool bPresent;
         char strSize[32];       /* Flawfinder: ignore */        
@@ -107,24 +107,24 @@ typedef struct ProcessorCache
         unsigned int uiLineSize;
         bool bSectored;
         char strCache[128];     /* Flawfinder: ignore */        
-} ProcessorCache;
+};
 
-typedef struct ProcessorL1Cache
+struct ProcessorL1Cache
 {
     ProcessorCache Instruction;
         ProcessorCache Data;
-} ProcessorL1Cache;
+};
 
-typedef struct ProcessorTLB
+struct ProcessorTLB
 {
         bool bPresent;
         char strPageSize[32];   /* Flawfinder: ignore */        
         unsigned int uiAssociativeWays;
         unsigned int uiEntries;
         char strTLB[128];       /* Flawfinder: ignore */        
-} ProcessorTLB;
+};
 
-typedef struct ProcessorInfo
+struct ProcessorInfo
 {
         char strVendor[16];     /* Flawfinder: ignore */        
         unsigned int uiFamily;
@@ -148,7 +148,7 @@ typedef struct ProcessorInfo
         ProcessorCache _Trace;
         ProcessorTLB _Instruction;
         ProcessorTLB _Data;
-} ProcessorInfo;
+};
 
 
 // CProcessor
diff --git a/linden/indra/llcommon/llsdserialize.cpp b/linden/indra/llcommon/llsdserialize.cpp
index d42842d..f21ff68 100644
--- a/linden/indra/llcommon/llsdserialize.cpp
+++ b/linden/indra/llcommon/llsdserialize.cpp
@@ -324,7 +324,7 @@ S32 LLSDParser::parse(std::istream& istr, LLSD& data, S32 max_bytes)
 S32 LLSDParser::parseLines(std::istream& istr, LLSD& data)
 {
         mCheckLimits = false;
-        mParseLines = false;            // was true, Emergency fix DEV-17785 parsing newline failure
+        mParseLines = true;
         return doParse(istr, data);
 }
 
diff --git a/linden/indra/llcommon/llsdserialize_xml.cpp b/linden/indra/llcommon/llsdserialize_xml.cpp
index 690ab67..9c3f85e 100644
--- a/linden/indra/llcommon/llsdserialize_xml.cpp
+++ b/linden/indra/llcommon/llsdserialize_xml.cpp
@@ -461,11 +461,11 @@ S32 LLSDXMLParser::Impl::parseLines(std::istream& input, LLSD& data)
                                 input.clear();
                         }
                 
-                        // Don't parse the NULL at the end which might be added if \n was absorbed by getline()
+                        // Re-insert with the \n that was absorbed by getline()
                         char * text = (char *) buffer;
                         if ( text[num_read - 1] == 0)
                         {
-                                num_read--;
+                                text[num_read - 1] = '\n';
                         }
                 }
 
@@ -808,12 +808,11 @@ void LLSDXMLParser::parsePart(const char *buf, int len)
 // virtual
 S32 LLSDXMLParser::doParse(std::istream& input, LLSD& data) const
 {
-// Remove code - emergency fix DEV-17785 parsing newline failure
-//      if (mParseLines)
-//      {
+        if (mParseLines)
+        {
                 // Use line-based reading (faster code)
-//              return impl.parseLines(input, data);
-//      }
+                return impl.parseLines(input, data);
+        }
 
         return impl.parse(input, data);
 }
diff --git a/linden/indra/llcommon/llstat.cpp b/linden/indra/llcommon/llstat.cpp
index 4b79fcb..706acdb 100644
--- a/linden/indra/llcommon/llstat.cpp
+++ b/linden/indra/llcommon/llstat.cpp
@@ -31,55 +31,288 @@
 #include "linden_common.h"
 
 #include "llstat.h"
+#include "lllivefile.h"
+#include "llerrorcontrol.h"
 #include "llframetimer.h"
 #include "timing.h"
+#include "llsd.h"
+#include "llsdserialize.h"
+#include "llstl.h"
+#include "u64.h"
 
-class LLStatAccum::impl
+
+// statics
+BOOL            LLPerfBlock::sStatsEnabled = FALSE;    // Flag for detailed information
+LLPerfBlock::stat_map_t    LLPerfBlock::sStatMap;    // Map full path string to LLStatTime objects, tracks all active objects
+std::string        LLPerfBlock::sCurrentStatPath = "";    // Something like "/total_time/physics/physics step"
+
+//------------------------------------------------------------------------
+// Live config file to trigger stats logging
+static const char    STATS_CONFIG_FILE_NAME[]            = "/dev/shm/simperf/simperf_proc_config.llsd";
+static const F32    STATS_CONFIG_REFRESH_RATE            = 5.0;        // seconds
+
+class LLStatsConfigFile : public LLLiveFile
 {
 public:
-        static const TimeScale IMPL_NUM_SCALES = (TimeScale)(SCALE_TWO_MINUTE + 1);
-        static U64 sScaleTimes[IMPL_NUM_SCALES];
+    LLStatsConfigFile()
+        : LLLiveFile(filename(), STATS_CONFIG_REFRESH_RATE),
+        mChanged(false), mStatsp(NULL) { }
 
-        BOOL    mUseFrameTimer;
+    static std::string filename();
+    
+protected:
+    /* virtual */ void loadFile();
 
-        BOOL    mRunning;
-        U64             mLastTime;
-        
-        struct Bucket
-        {
-                F64             accum;
-                U64             endTime;
+public:
+    void init(LLPerfStats* statsp);
+    static LLStatsConfigFile& instance();
+        // return the singleton stats config file
 
-                BOOL    lastValid;
-                F64             lastAccum;
-        };
+    bool mChanged;
 
-        Bucket  mBuckets[IMPL_NUM_SCALES];
+protected:
+    LLPerfStats*    mStatsp;
+};
 
-        BOOL    mLastSampleValid;
-        F64     mLastSampleValue;
+std::string LLStatsConfigFile::filename()
+{
+    return STATS_CONFIG_FILE_NAME;
+}
 
+void LLStatsConfigFile::init(LLPerfStats* statsp)
+{
+    mStatsp = statsp;
+}
 
-        impl(bool useFrameTimer);
+LLStatsConfigFile& LLStatsConfigFile::instance()
+{
+    static LLStatsConfigFile the_file;
+    return the_file;
+}
 
-        void reset(U64 when);
 
-        void sum(F64 value);
-        void sum(F64 value, U64 when);
+/* virtual */
+// Load and parse the stats configuration file
+void LLStatsConfigFile::loadFile()
+{
+    if (!mStatsp)
+    {
+        llwarns << "Tries to load performance configure file without initializing LPerfStats" << llendl;
+        return;
+    }
+    mChanged = true;
+    
+    LLSD stats_config;
+    {
+        llifstream file(filename().c_str());
+        if (file.is_open())
+        {
+            LLSDSerialize::fromXML(stats_config, file);
+            if (stats_config.isUndefined())
+            {
+                llinfos << "Performance statistics configuration file ill-formed, not recording statistics" << llendl;
+                mStatsp->setReportPerformanceDuration( 0.f );
+                return;
+            }
+        }
+        else 
+        {    // File went away, turn off stats if it was on
+            if ( mStatsp->frameStatsIsRunning() )
+            {
+                llinfos << "Performance statistics configuration file deleted, not recording statistics" << llendl;
+                mStatsp->setReportPerformanceDuration( 0.f );
+            }
+            return;
+        }
+    }
+
+    F32 duration = 0.f;
+    F32 interval = 0.f;
+
+    const char * w = "duration";
+    if (stats_config.has(w))
+    {
+        duration = (F32)stats_config[w].asReal();
+    } 
+    w = "interval";
+    if (stats_config.has(w))
+    {
+        interval = (F32)stats_config[w].asReal();
+    } 
+
+    mStatsp->setReportPerformanceDuration( duration );
+    mStatsp->setReportPerformanceInterval( interval );
+
+    if ( duration > 0 )
+    {
+        if ( interval == 0.f )
+        {
+            llinfos << "Recording performance stats every frame for " << duration << " sec" << llendl;
+        }
+        else
+        {
+            llinfos << "Recording performance stats every " << interval << " seconds for " << duration << " seconds" << llendl;
+        }
+    }
+    else
+    {
+        llinfos << "Performance stats recording turned off" << llendl;
+    }
+}
 
-        F32 meanValue(TimeScale scale) const;
 
-        U64 getCurrentUsecs() const;
-                // Get current microseconds based on timer type
-};
+//------------------------------------------------------------------------
 
+LLPerfStats::LLPerfStats(const std::string& process_name, S32 process_pid) : 
+    mFrameStatsFileFailure(FALSE),
+    mSkipFirstFrameStats(FALSE),
+    mProcessName(process_name),
+    mProcessPID(process_pid),
+    mReportPerformanceStatInterval(1.f),
+    mReportPerformanceStatEnd(0.0) 
+{ }
 
-U64 LLStatAccum::impl::sScaleTimes[IMPL_NUM_SCALES] =
+LLPerfStats::~LLPerfStats()
+{
+    LLPerfBlock::clearDynamicStats();
+    mFrameStatsFile.close();
+}
+
+void LLPerfStats::init()
+{
+    // Initialize the stats config file instance.
+    (void) LLStatsConfigFile::instance().init(this);
+    (void) LLStatsConfigFile::instance().checkAndReload();
+}
+
+// Open file for statistics
+void    LLPerfStats::openPerfStatsFile()
+{
+    if ( !mFrameStatsFile
+        && !mFrameStatsFileFailure )
+    {
+        std::string stats_file = llformat("/dev/shm/simperf/%s_proc.%d.llsd", mProcessName.c_str(), mProcessPID);
+        mFrameStatsFile.close();
+        mFrameStatsFile.clear();
+        mFrameStatsFile.open(stats_file, llofstream::out);
+        if ( mFrameStatsFile.fail() )
+        {
+            llinfos << "Error opening statistics log file " << stats_file << llendl;
+            mFrameStatsFileFailure = TRUE;
+        }
+        else
+        {
+            LLSD process_info = LLSD::emptyMap();
+            process_info["name"] = mProcessName;
+            process_info["pid"] = (LLSD::Integer) mProcessPID;
+            process_info["stat_rate"] = (LLSD::Integer) mReportPerformanceStatInterval;
+            // Add process-specific info.
+            addProcessHeaderInfo(process_info);
+
+            mFrameStatsFile << LLSDNotationStreamer(process_info) << std::endl; 
+        }
+    }
+}
+
+// Dump out performance metrics over some time interval
+void LLPerfStats::dumpIntervalPerformanceStats()
+{
+    // Ensure output file is OK
+    openPerfStatsFile();
+
+    if ( mFrameStatsFile )
+    {
+        LLSD stats = LLSD::emptyMap();
+
+        LLStatAccum::TimeScale scale;
+        if ( getReportPerformanceInterval() == 0.f )
+        {
+            scale = LLStatAccum::SCALE_PER_FRAME;
+        }
+        else if ( getReportPerformanceInterval() < 0.5f )
+        {
+            scale = LLStatAccum::SCALE_100MS;
+        }
+        else
+        {
+            scale = LLStatAccum::SCALE_SECOND;
+        }
+
+        // Write LLSD into log
+        stats["utc_time"] = (LLSD::String) LLError::utcTime();
+        stats["timestamp"] = U64_to_str((totalTime() / 1000) + (gUTCOffset * 1000));    // milliseconds since epoch
+        stats["frame_number"] = (LLSD::Integer) LLFrameTimer::getFrameCount();
+
+        // Add process-specific frame info.
+        addProcessFrameInfo(stats, scale);
+        LLPerfBlock::addStatsToLLSDandReset( stats, scale );
+
+        mFrameStatsFile << LLSDNotationStreamer(stats) << std::endl; 
+    }
+}
+
+// Set length of performance stat recording
+void    LLPerfStats::setReportPerformanceDuration( F32 seconds )
+{ 
+        if ( seconds <= 0.f )
+        {
+                mReportPerformanceStatEnd = 0.0;
+                LLPerfBlock::setStatsEnabled( FALSE );
+                mFrameStatsFile.close();
+                LLPerfBlock::clearDynamicStats();
+        }
+        else
+        {
+                mReportPerformanceStatEnd = LLFrameTimer::getElapsedSeconds() + ((F64) seconds);
+                // Clear failure flag to try and create the log file once
+                mFrameStatsFileFailure = FALSE;
+                LLPerfBlock::setStatsEnabled( TRUE );
+                mSkipFirstFrameStats = TRUE;            // Skip the first report (at the end of this frame)
+        }
+}
+
+void LLPerfStats::updatePerFrameStats()
+{
+    (void) LLStatsConfigFile::instance().checkAndReload();
+        static LLFrameTimer performance_stats_timer;
+        if ( frameStatsIsRunning() )
+        {
+                if ( mReportPerformanceStatInterval == 0 )
+                {       // Record info every frame
+                        if ( mSkipFirstFrameStats )
+                        {       // Skip the first time - was started this frame
+                                mSkipFirstFrameStats = FALSE;
+                        }
+                        else
+                        {
+                                dumpIntervalPerformanceStats();
+                        }
+                }
+                else
+                {
+                        performance_stats_timer.setTimerExpirySec( getReportPerformanceInterval() );
+                        if (performance_stats_timer.checkExpirationAndReset( mReportPerformanceStatInterval ))
+                        {
+                                dumpIntervalPerformanceStats();
+                        }
+                }
+                
+                if ( LLFrameTimer::getElapsedSeconds() > mReportPerformanceStatEnd )
+                {       // Reached end of time, clear it to stop reporting
+                        setReportPerformanceDuration(0.f);                      // Don't set mReportPerformanceStatEnd directly 
+            llinfos << "Recording performance stats completed" << llendl;
+                }
+        }
+}
+
+
+//------------------------------------------------------------------------
+
+U64 LLStatAccum::sScaleTimes[NUM_SCALES] =
 {
         USEC_PER_SEC / 10,                              // 100 millisec
         USEC_PER_SEC * 1,                               // seconds
         USEC_PER_SEC * 60,                              // minutes
-        USEC_PER_SEC * 60 * 2                   // two minutes
 #if ENABLE_LONG_TIME_STATS
         // enable these when more time scales are desired
         USEC_PER_SEC * 60*60,                   // hours
@@ -89,19 +322,27 @@ U64 LLStatAccum::impl::sScaleTimes[IMPL_NUM_SCALES] =
 };
 
 
-LLStatAccum::impl::impl(bool useFrameTimer)
+
+LLStatAccum::LLStatAccum(bool useFrameTimer)
+        : mUseFrameTimer(useFrameTimer),
+          mRunning(FALSE),
+          mLastSampleValue(0.0),
+          mLastSampleValid(FALSE)
+{
+}
+
+LLStatAccum::~LLStatAccum()
 {
-        mUseFrameTimer = useFrameTimer;
-        mRunning = FALSE;
-        mLastSampleValid = FALSE;
 }
 
-void LLStatAccum::impl::reset(U64 when)
+
+
+void LLStatAccum::reset(U64 when)
 {
         mRunning = TRUE;
         mLastTime = when;
 
-        for (int i = 0; i < IMPL_NUM_SCALES; ++i)
+        for (int i = 0; i < NUM_SCALES; ++i)
         {
                 mBuckets[i].accum = 0.0;
                 mBuckets[i].endTime = when + sScaleTimes[i];
@@ -109,12 +350,12 @@ void LLStatAccum::impl::reset(U64 when)
         }
 }
 
-void LLStatAccum::impl::sum(F64 value)
+void LLStatAccum::sum(F64 value)
 {
         sum(value, getCurrentUsecs());
 }
 
-void LLStatAccum::impl::sum(F64 value, U64 when)
+void LLStatAccum::sum(F64 value, U64 when)
 {
         if (!mRunning)
         {
@@ -131,7 +372,10 @@ void LLStatAccum::impl::sum(F64 value, U64 when)
                 return;
         }
 
-        for (int i = 0; i < IMPL_NUM_SCALES; ++i)
+        // how long is this value for
+        U64 timeSpan = when - mLastTime;
+
+        for (int i = 0; i < NUM_SCALES; ++i)
         {
                 Bucket& bucket = mBuckets[i];
 
@@ -143,8 +387,6 @@ void LLStatAccum::impl::sum(F64 value, U64 when)
                 {
                         U64 timeScale = sScaleTimes[i];
 
-                        U64 timeSpan = when - mLastTime;
-                                // how long is this value for
                         U64 timeLeft = when - bucket.endTime;
                                 // how much time is left after filling this bucket
                         
@@ -173,13 +415,18 @@ void LLStatAccum::impl::sum(F64 value, U64 when)
 }
 
 
-F32 LLStatAccum::impl::meanValue(TimeScale scale) const
+F32 LLStatAccum::meanValue(TimeScale scale) const
 {
         if (!mRunning)
         {
                 return 0.0;
         }
-        if (scale < 0 || scale >= IMPL_NUM_SCALES)
+        if ( scale == SCALE_PER_FRAME )
+        {       // Per-frame not supported here
+                scale = SCALE_100MS;
+        }
+
+        if (scale < 0 || scale >= NUM_SCALES)
         {
                 llwarns << "llStatAccum::meanValue called for unsupported scale: "
                         << scale << llendl;
@@ -209,7 +456,7 @@ F32 LLStatAccum::impl::meanValue(TimeScale scale) const
 }
 
 
-U64 LLStatAccum::impl::getCurrentUsecs() const
+U64 LLStatAccum::getCurrentUsecs() const
 {
         if (mUseFrameTimer)
         {
@@ -222,25 +469,44 @@ U64 LLStatAccum::impl::getCurrentUsecs() const
 }
 
 
+// ------------------------------------------------------------------------
 
-
-
-LLStatAccum::LLStatAccum(bool useFrameTimer)
-        : m(* new impl(useFrameTimer))
+LLStatRate::LLStatRate(bool use_frame_timer)
+        : LLStatAccum(use_frame_timer)
 {
 }
 
-LLStatAccum::~LLStatAccum()
+void LLStatRate::count(U32 value)
 {
-        delete &m;
+        sum((F64)value * sScaleTimes[SCALE_SECOND]);
 }
 
-F32 LLStatAccum::meanValue(TimeScale scale) const
-{
-        return m.meanValue(scale);
-}
+
+void LLStatRate::mark()
+ { 
+        // Effectively the same as count(1), but sets mLastSampleValue
+        U64 when = getCurrentUsecs();
+
+        if ( mRunning 
+                 && (when > mLastTime) )
+        {       // Set mLastSampleValue to the time from the last mark()
+                F64 duration = ((F64)(when - mLastTime)) / sScaleTimes[SCALE_SECOND];
+                if ( duration > 0.0 )
+                {
+                        mLastSampleValue = 1.0 / duration;
+                }
+                else
+                {
+                        mLastSampleValue = 0.0;
+                }
+        }
+
+        sum( (F64) sScaleTimes[SCALE_SECOND], when);
+ }
 
 
+// ------------------------------------------------------------------------
+
 
 LLStatMeasure::LLStatMeasure(bool use_frame_timer)
         : LLStatAccum(use_frame_timer)
@@ -249,53 +515,209 @@ LLStatMeasure::LLStatMeasure(bool use_frame_timer)
 
 void LLStatMeasure::sample(F64 value)
 {
-        U64 when = m.getCurrentUsecs();
+        U64 when = getCurrentUsecs();
 
-        if (m.mLastSampleValid)
+        if (mLastSampleValid)
         {
-                F64 avgValue = (value + m.mLastSampleValue) / 2.0;
-                F64 interval = (F64)(when - m.mLastTime);
+                F64 avgValue = (value + mLastSampleValue) / 2.0;
+                F64 interval = (F64)(when - mLastTime);
 
-                m.sum(avgValue * interval, when);
+                sum(avgValue * interval, when);
         }
         else
         {
-                m.reset(when);
+                reset(when);
         }
 
-        m.mLastSampleValid = TRUE;
-        m.mLastSampleValue = value;
+        mLastSampleValid = TRUE;
+        mLastSampleValue = value;
 }
 
 
-LLStatRate::LLStatRate(bool use_frame_timer)
-        : LLStatAccum(use_frame_timer)
+// ------------------------------------------------------------------------
+
+LLStatTime::LLStatTime(const std::string & key)
+        : LLStatAccum(false),
+          mFrameNumber(LLFrameTimer::getFrameCount()),
+          mTotalTimeInFrame(0),
+          mKey(key)
+#if LL_DEBUG
+          , mRunning(FALSE)
+#endif
 {
 }
 
-void LLStatRate::count(U32 value)
+void LLStatTime::start()
+{
+        // Reset frame accumluation if the frame number has changed
+        U32 frame_number = LLFrameTimer::getFrameCount();
+        if ( frame_number != mFrameNumber )
+        {
+                mFrameNumber = frame_number;
+                mTotalTimeInFrame = 0;
+        }
+
+        sum(0.0);
+
+#if LL_DEBUG
+        // Shouldn't be running already
+        llassert( !mRunning );
+        mRunning = TRUE;
+#endif
+}
+
+void LLStatTime::stop()
+{
+        U64 end_time = getCurrentUsecs();
+        U64 duration = end_time - mLastTime;
+        sum(F64(duration), end_time);
+        //llinfos << "mTotalTimeInFrame incremented from  " << mTotalTimeInFrame << " to " << (mTotalTimeInFrame + duration) << llendl; 
+        mTotalTimeInFrame += duration;
+
+#if LL_DEBUG
+        mRunning = FALSE;
+#endif
+}
+
+/* virtual */ F32 LLStatTime::meanValue(TimeScale scale) const
 {
-        m.sum((F64)value * impl::sScaleTimes[SCALE_SECOND]);
+    if ( LLStatAccum::SCALE_PER_FRAME == scale )
+    {
+        return mTotalTimeInFrame;
+    }
+    else
+    {
+        return LLStatAccum::meanValue(scale);
+    }
 }
 
 
-LLStatTime::LLStatTime(bool use_frame_timer)
-        : LLStatAccum(use_frame_timer)
+// ------------------------------------------------------------------------
+
+
+// Use this constructor for pre-defined LLStatTime objects
+LLPerfBlock::LLPerfBlock(LLStatTime* stat ) : mPredefinedStat(stat), mDynamicStat(NULL)
 {
+    if (mPredefinedStat)
+    {
+        // If dynamic stats are turned on, this will create a separate entry in the stat map.
+        initDynamicStat(mPredefinedStat->mKey);
+
+        // Start predefined stats.  These stats are not part of the stat map.
+        mPredefinedStat->start();
+    }
 }
 
-void LLStatTime::start()
+// Use this constructor for dynamically created LLStatTime objects (not pre-defined) with a multi-part key.
+// These are also turned on or off via the switch passed in
+LLPerfBlock::LLPerfBlock( const char* key1, const char* key2 ) : mPredefinedStat(NULL), mDynamicStat(NULL)
 {
-        m.sum(0.0);
+    if (!sStatsEnabled) return;
+
+    if (NULL == key2 || strlen(key2) == 0)
+    {
+        initDynamicStat(key1);
+    }
+    else
+    {
+        std::ostringstream key;
+        key << key1 << "_" << key2;
+        initDynamicStat(key.str());
+    }
 }
 
-void LLStatTime::stop()
+void LLPerfBlock::initDynamicStat(const std::string& key)
+{
+    // Early exit if dynamic stats aren't enabled.
+    if (!sStatsEnabled) return;
+
+    mLastPath = sCurrentStatPath;               // Save and restore current path
+    sCurrentStatPath += "/" + key;              // Add key to current path
+
+    // See if the LLStatTime object already exists
+    stat_map_t::iterator iter = sStatMap.find(sCurrentStatPath);
+    if ( iter == sStatMap.end() )
+    {
+        // StatEntry object doesn't exist, so create it
+        mDynamicStat = new StatEntry( key );
+        sStatMap[ sCurrentStatPath ] = mDynamicStat;    // Set the entry for this path
+    }
+    else
+    {
+        // Found this path in the map, use the object there
+        mDynamicStat = (*iter).second;          // Get StatEntry for the current path
+    }
+
+    if (mDynamicStat)
+    {
+        mDynamicStat->mStat.start();
+        mDynamicStat->mCount++;
+    }
+    else
+    {
+        llwarns << "Initialized NULL dynamic stat at '" << sCurrentStatPath << "'" << llendl;
+       sCurrentStatPath = mLastPath;
+    }
+}
+
+
+// Destructor does the time accounting
+LLPerfBlock::~LLPerfBlock()
+{
+    if (mPredefinedStat) mPredefinedStat->stop();
+    if (mDynamicStat)
+    {
+        mDynamicStat->mStat.stop();
+        sCurrentStatPath = mLastPath;   // Restore the path in case sStatsEnabled changed during this block
+    }
+}
+
+
+// Clear the map of any dynamic stats.  Static routine
+void LLPerfBlock::clearDynamicStats()
+{
+    std::for_each(sStatMap.begin(), sStatMap.end(), DeletePairedPointer());
+    sStatMap.clear();
+}
+
+// static - Extract the stat info into LLSD
+void LLPerfBlock::addStatsToLLSDandReset( LLSD & stats,
+                                                                                  LLStatAccum::TimeScale scale )
 {
-        U64 endTime = m.getCurrentUsecs();
-        m.sum((F64)(endTime - m.mLastTime), endTime);
+    // If we aren't in per-frame scale, we need to go from second to microsecond.
+    U32 scale_adjustment = 1;
+    if (LLStatAccum::SCALE_PER_FRAME != scale)
+    {
+        scale_adjustment = USEC_PER_SEC;
+    }
+        stat_map_t::iterator iter = sStatMap.begin();
+        for ( ; iter != sStatMap.end(); ++iter )
+        {       // Put the entry into LLSD "/full/path/to/stat/" = microsecond total time
+                const std::string & stats_full_path = (*iter).first;
+
+                StatEntry * stat = (*iter).second;
+                if (stat)
+                {
+            if (stat->mCount > 0)
+            {
+                stats[stats_full_path] = LLSD::emptyMap();
+                stats[stats_full_path]["us"] = (LLSD::Integer) (scale_adjustment * stat->mStat.meanValue(scale));
+                if (stat->mCount > 1)
+                {
+                    stats[stats_full_path]["count"] = (LLSD::Integer) stat->mCount;
+                }
+                stat->mCount = 0;
+            }
+                }
+                else
+                {       // WTF?  Shouldn't have a NULL pointer in the map.
+            llwarns << "Unexpected NULL dynamic stat at '" << stats_full_path << "'" << llendl;
+                }
+        }       
 }
 
 
+// ------------------------------------------------------------------------
 
 LLTimer LLStat::sTimer;
 LLFrameTimer LLStat::sFrameTimer;
diff --git a/linden/indra/llcommon/llstat.h b/linden/indra/llcommon/llstat.h
index 0a7e014..63813e2 100644
--- a/linden/indra/llcommon/llstat.h
+++ b/linden/indra/llcommon/llstat.h
@@ -33,9 +33,13 @@
 #define LL_LLSTAT_H
 
 #include <deque>
+#include <map>
 
 #include "lltimer.h"
 #include "llframetimer.h"
+#include "llfile.h"
+
+class   LLSD;
 
 // Set this if longer stats are needed
 #define ENABLE_LONG_TIME_STATS  0
@@ -58,25 +62,50 @@ public:
                 SCALE_100MS,
                 SCALE_SECOND,
                 SCALE_MINUTE,
-                SCALE_TWO_MINUTE,
 #if ENABLE_LONG_TIME_STATS
                 SCALE_HOUR,
                 SCALE_DAY,
                 SCALE_WEEK,
 #endif
-                NUM_SCALES
+                NUM_SCALES,                     // Use to size storage arrays
+                SCALE_PER_FRAME         // For latest frame information - should be after NUM_SCALES since this doesn't go into the time buckets
         };
 
-        F32 meanValue(TimeScale scale) const;
+        static U64 sScaleTimes[NUM_SCALES];
+
+        virtual F32 meanValue(TimeScale scale) const;
                 // see the subclasses for the specific meaning of value
 
         F32 meanValueOverLast100ms()  const { return meanValue(SCALE_100MS);  }
         F32 meanValueOverLastSecond() const     { return meanValue(SCALE_SECOND); }
         F32 meanValueOverLastMinute() const     { return meanValue(SCALE_MINUTE); }
 
-protected:
-        class impl;
-        impl& m;
+        void reset(U64 when);
+
+        void sum(F64 value);
+        void sum(F64 value, U64 when);
+
+        U64 getCurrentUsecs() const;
+                // Get current microseconds based on timer type
+
+        BOOL    mUseFrameTimer;
+        BOOL    mRunning;
+
+        U64             mLastTime;
+        
+        struct Bucket
+        {
+                F64             accum;
+                U64             endTime;
+
+                BOOL    lastValid;
+                F64             lastAccum;
+        };
+
+        Bucket  mBuckets[NUM_SCALES];
+
+        BOOL    mLastSampleValid;
+        F64     mLastSampleValue;
 };
 
 class LLStatMeasure : public LLStatAccum
@@ -105,39 +134,120 @@ public:
         void count(U32);
                 // used to note that n items have occured
         
-        void mark() { count(1); }
+        void mark();
                 // used for counting the rate thorugh a point in the code
 };
 
 
-class LLTimeBlock;
-
 class LLStatTime : public LLStatAccum
         // gathers statistics about time spent in a block of code
         // measure average duration per second in the block
 {
 public:
-        LLStatTime(bool use_frame_timer = false);
+        LLStatTime( const std::string & key = "undefined" );
+
+        U32             mFrameNumber;           // Current frame number
+        U64             mTotalTimeInFrame;      // Total time (microseconds) accumulated during the last frame
+
+        void    setKey( const std::string & key )               { mKey = key;   };
+
+        virtual F32 meanValue(TimeScale scale) const;
 
 private:
-        void start();
+        void start();                           // Start and stop measuring time block
         void stop();
-        friend class LLTimeBlock;
+
+        std::string             mKey;           // Tag representing this time block
+
+#if LL_DEBUG
+        BOOL                    mRunning;       // TRUE if start() has been called
+#endif
+
+        friend class LLPerfBlock;
 };
 
-class LLTimeBlock
+// ----------------------------------------------------------------------------
+
+
+// Use this class on the stack to record statistics about an area of code
+class LLPerfBlock
 {
 public:
-        LLTimeBlock(LLStatTime& stat) : mStat(stat) { mStat.start(); }
-        ~LLTimeBlock()                                                          { mStat.stop(); }
+    struct StatEntry
+    {
+            StatEntry(const std::string& key) : mStat(LLStatTime(key)), mCount(0) {}
+            LLStatTime  mStat;
+            U32         mCount;
+    };
+    typedef std::map<std::string, StatEntry*>           stat_map_t;
+
+        // Use this constructor for pre-defined LLStatTime objects
+        LLPerfBlock(LLStatTime* stat);
+
+        // Use this constructor for dynamically created LLStatTime objects (not pre-defined) with a multi-part key
+        LLPerfBlock( const char* key1, const char* key2 = NULL);
+
+
+        ~LLPerfBlock();
+
+        static void setStatsEnabled( BOOL enable )              { sStatsEnabled = enable;       };
+        static S32  getStatsEnabled()                                   { return sStatsEnabled;         };
+
+        static void clearDynamicStats();                // Reset maps to clear out dynamic objects
+        static void addStatsToLLSDandReset( LLSD & stats,               // Get current information and clear time bin
+                                                                                LLStatAccum::TimeScale scale );
+
 private:
-        LLStatTime& mStat;
+        // Initialize dynamically created LLStatTime objects
+    void initDynamicStat(const std::string& key);
+
+        std::string                             mLastPath;                              // Save sCurrentStatPath when this is called
+        LLStatTime *                    mPredefinedStat;                // LLStatTime object to get data
+        StatEntry *                             mDynamicStat;                   // StatEntryobject to get data
+
+        static BOOL                             sStatsEnabled;                  // Normally FALSE
+    static stat_map_t           sStatMap;                               // Map full path string to LLStatTime objects
+        static std::string              sCurrentStatPath;               // Something like "frame/physics/physics step"
 };
 
+// ----------------------------------------------------------------------------
 
+class LLPerfStats
+{
+public:
+    LLPerfStats(const std::string& process_name = "unknown", S32 process_pid = 0);
+    virtual ~LLPerfStats();
+
+    virtual void init();    // Reset and start all stat timers
+    virtual void updatePerFrameStats();
+    // Override these function to add process-specific information to the performance log header and per-frame logging.
+    virtual void addProcessHeaderInfo(LLSD& info) { /* not implemented */ }
+    virtual void addProcessFrameInfo(LLSD& info, LLStatAccum::TimeScale scale) { /* not implemented */ }
+
+    // High-resolution frame stats
+    BOOL    frameStatsIsRunning()                                { return (mReportPerformanceStatEnd > 0.);        };
+    F32     getReportPerformanceInterval() const                { return mReportPerformanceStatInterval;        };
+    void    setReportPerformanceInterval( F32 interval )        { mReportPerformanceStatInterval = interval;    };
+    void    setReportPerformanceDuration( F32 seconds );
+    void    setProcessName(const std::string& process_name) { mProcessName = process_name; }
+    void    setProcessPID(S32 process_pid) { mProcessPID = process_pid; }
 
+protected:
+    void    openPerfStatsFile();                    // Open file for high resolution metrics logging
+    void    dumpIntervalPerformanceStats();
+
+    llofstream      mFrameStatsFile;            // File for per-frame stats
+    BOOL            mFrameStatsFileFailure;        // Flag to prevent repeat opening attempts
+    BOOL            mSkipFirstFrameStats;        // Flag to skip one (partial) frame report
+    std::string     mProcessName;
+    S32             mProcessPID;
 
+private:
+    F32 mReportPerformanceStatInterval;    // Seconds between performance stats
+    F64 mReportPerformanceStatEnd;        // End time (seconds) for performance stats
+};
 
+// ----------------------------------------------------------------------------
 class LLStat
 {
 public:
diff --git a/linden/indra/llcommon/llstatenums.h b/linden/indra/llcommon/llstatenums.h
index 6866586..1d9b863 100644
--- a/linden/indra/llcommon/llstatenums.h
+++ b/linden/indra/llcommon/llstatenums.h
@@ -33,38 +33,41 @@
 
 enum
 {
-        LL_SIM_STAT_TIME_DILATION,
+        LL_SIM_STAT_TIME_DILATION,                              // 0
         LL_SIM_STAT_FPS,
         LL_SIM_STAT_PHYSFPS,
         LL_SIM_STAT_AGENTUPS,
         LL_SIM_STAT_FRAMEMS,
-        LL_SIM_STAT_NETMS,
+        LL_SIM_STAT_NETMS,                                              // 5
         LL_SIM_STAT_SIMOTHERMS,
         LL_SIM_STAT_SIMPHYSICSMS,
         LL_SIM_STAT_AGENTMS,
         LL_SIM_STAT_IMAGESMS,
-        LL_SIM_STAT_SCRIPTMS,
+        LL_SIM_STAT_SCRIPTMS,                                   // 10
         LL_SIM_STAT_NUMTASKS,
         LL_SIM_STAT_NUMTASKSACTIVE,
         LL_SIM_STAT_NUMAGENTMAIN,
         LL_SIM_STAT_NUMAGENTCHILD,
-        LL_SIM_STAT_NUMSCRIPTSACTIVE,
+        LL_SIM_STAT_NUMSCRIPTSACTIVE,                   // 15
         LL_SIM_STAT_LSLIPS,
         LL_SIM_STAT_INPPS,
         LL_SIM_STAT_OUTPPS,
         LL_SIM_STAT_PENDING_DOWNLOADS,
-        LL_SIM_STAT_PENDING_UPLOADS,
+        LL_SIM_STAT_PENDING_UPLOADS,                    // 20
         LL_SIM_STAT_VIRTUAL_SIZE_KB,
         LL_SIM_STAT_RESIDENT_SIZE_KB,
         LL_SIM_STAT_PENDING_LOCAL_UPLOADS,
         LL_SIM_STAT_TOTAL_UNACKED_BYTES,
-        LL_SIM_STAT_PHYSICS_PINNED_TASKS,
+        LL_SIM_STAT_PHYSICS_PINNED_TASKS,               // 25
         LL_SIM_STAT_PHYSICS_LOD_TASKS,
         LL_SIM_STAT_SIMPHYSICSSTEPMS,
         LL_SIM_STAT_SIMPHYSICSSHAPEMS,
         LL_SIM_STAT_SIMPHYSICSOTHERMS,
-        LL_SIM_STAT_SIMPHYSICSMEMORY,
+        LL_SIM_STAT_SIMPHYSICSMEMORY,                   // 30
         LL_SIM_STAT_SCRIPT_EPS,
+        LL_SIM_STAT_SIMSPARETIME,
+        LL_SIM_STAT_SIMSLEEPTIME,
+        LL_SIM_STAT_IOPUMPTIME,
 };
 
 #endif
diff --git a/linden/indra/llcommon/llstl.h b/linden/indra/llcommon/llstl.h
index 4486727..70a2cc0 100644
--- a/linden/indra/llcommon/llstl.h
+++ b/linden/indra/llcommon/llstl.h
@@ -79,6 +79,9 @@ struct compare_pointer_contents
 // The general form is:
 //
 //  std::for_each(cont.begin(), cont.end(), DeletePointer());
+//  somemap.clear();
+//
+// Don't forget to clear()!
 
 struct DeletePointer
 {
@@ -95,7 +98,7 @@ struct DeletePointerArray
         }
 };
 
-// DeletePointer is a simple helper for deleting all pointers in a map.
+// DeletePairedPointer is a simple helper for deleting all pointers in a map.
 // The general form is:
 //
 //  std::for_each(somemap.begin(), somemap.end(), DeletePairedPointer());
diff --git a/linden/indra/llcommon/llstring.h b/linden/indra/llcommon/llstring.h
index 7b08fd3..5e75188 100644
--- a/linden/indra/llcommon/llstring.h
+++ b/linden/indra/llcommon/llstring.h
@@ -133,26 +133,32 @@ struct char_traits<U16>
 class LLStringOps
 {
 public:
-        static char toUpper(char elem) { return toupper(elem); }
+        static char toUpper(char elem) { return toupper((unsigned char)elem); }
         static llwchar toUpper(llwchar elem) { return towupper(elem); }
         
-        static char toLower(char elem) { return tolower(elem); }
+        static char toLower(char elem) { return tolower((unsigned char)elem); }
         static llwchar toLower(llwchar elem) { return towlower(elem); }
 
-        static BOOL isSpace(char elem) { return isspace(elem) != 0; }
-        static BOOL isSpace(llwchar elem) { return iswspace(elem) != 0; }
+        static bool isSpace(char elem) { return isspace((unsigned char)elem) != 0; }
+        static bool isSpace(llwchar elem) { return iswspace(elem) != 0; }
 
-        static BOOL isUpper(char elem) { return isupper(elem) != 0; }
-        static BOOL isUpper(llwchar elem) { return iswupper(elem) != 0; }
+        static bool isUpper(char elem) { return isupper((unsigned char)elem) != 0; }
+        static bool isUpper(llwchar elem) { return iswupper(elem) != 0; }
 
-        static BOOL isLower(char elem) { return islower(elem) != 0; }
-        static BOOL isLower(llwchar elem) { return iswlower(elem) != 0; }
+        static bool isLower(char elem) { return islower((unsigned char)elem) != 0; }
+        static bool isLower(llwchar elem) { return iswlower(elem) != 0; }
+
+        static bool isDigit(char a) { return isdigit((unsigned char)a) != 0; }
+        static bool isDigit(llwchar a) { return iswdigit(a) != 0; }
+
+        static bool isPunct(char a) { return ispunct((unsigned char)a) != 0; }
+        static bool isPunct(llwchar a) { return iswpunct(a) != 0; }
+
+        static bool isAlnum(char a) { return isalnum((unsigned char)a) != 0; }
+        static bool isAlnum(llwchar a) { return iswalnum(a) != 0; }
 
         static S32      collate(const char* a, const char* b) { return strcoll(a, b); }
         static S32      collate(const llwchar* a, const llwchar* b);
-
-        static BOOL isDigit(char a) { return isdigit(a) != 0; }
-        static BOOL isDigit(llwchar a) { return iswdigit(a) != 0; }
 };
 
 /**
@@ -194,7 +200,7 @@ public:
         typedef std::map<LLFormatMapString, LLFormatMapString> format_map_t;
         static S32 format(std::basic_string<T>& s, const format_map_t& fmt_map);
         
-        static BOOL     isValidIndex(const std::basic_string<T>& string, size_type i)
+        static bool isValidIndex(const std::basic_string<T>& string, size_type i)
         {
                 return !string.empty() && (0 <= i) && (i <= string.size());
         }
@@ -1155,13 +1161,6 @@ BOOL LLStringUtilBase<T>::convertToU32(const std::basic_string<T>& string, U32&
         std::basic_istringstream<T> i_stream((std::basic_string<T>)temp);
         if(i_stream >> v)
         {
-                //TODO: figure out overflow reporting here
-                //if( ULONG_MAX == v )
-                //{
-                //      // Underflow or overflow
-                //      return FALSE;
-                //}
-
                 value = v;
                 return TRUE;
         }
diff --git a/linden/indra/llcommon/llthread.cpp b/linden/indra/llcommon/llthread.cpp
index 822adc2..8bc9aac 100644
--- a/linden/indra/llcommon/llthread.cpp
+++ b/linden/indra/llcommon/llthread.cpp
@@ -359,7 +359,7 @@ void LLCondition::broadcast()
 LLMutex* LLThreadSafeRefCount::sMutex = 0;
 
 //static
-void LLThreadSafeRefCount::initClass()
+void LLThreadSafeRefCount::initThreadSafeRefCount()
 {
         if (!sMutex)
         {
@@ -368,7 +368,7 @@ void LLThreadSafeRefCount::initClass()
 }
 
 //static
-void LLThreadSafeRefCount::cleanupClass()
+void LLThreadSafeRefCount::cleanupThreadSafeRefCount()
 {
         delete sMutex;
         sMutex = NULL;
diff --git a/linden/indra/llcommon/llthread.h b/linden/indra/llcommon/llthread.h
index 9da3134..923de56 100644
--- a/linden/indra/llcommon/llthread.h
+++ b/linden/indra/llcommon/llthread.h
@@ -191,8 +191,8 @@ void LLThread::unlockData()
 class LLThreadSafeRefCount
 {
 public:
-        static void initClass(); // creates sMutex
-        static void cleanupClass(); // destroys sMutex
+        static void initThreadSafeRefCount(); // creates sMutex
+        static void cleanupThreadSafeRefCount(); // destroys sMutex
         
 private:
         static LLMutex* sMutex;
diff --git a/linden/indra/llcommon/lltimer.cpp b/linden/indra/llcommon/lltimer.cpp
index 967570d..47edfd0 100644
--- a/linden/indra/llcommon/lltimer.cpp
+++ b/linden/indra/llcommon/lltimer.cpp
@@ -83,15 +83,20 @@ void ms_sleep(U32 ms)
 {
         Sleep(ms);
 }
+
+U32 micro_sleep(U64 us, U32 max_yields)
+{
+    // max_yields is unused; just fiddle with it to avoid warnings.
+    max_yields = 0;
+    ms_sleep(us / 1000);
+    return 0;
+}
 #elif LL_LINUX || LL_SOLARIS || LL_DARWIN
-void ms_sleep(U32 ms)
+static void _sleep_loop(struct timespec& thiswait)
 {
-        long mslong = ms; // tv_nsec is a long
-        struct timespec thiswait, nextwait;
+        struct timespec nextwait;
         bool sleep_more = false;
 
-        thiswait.tv_sec = ms / 1000;
-        thiswait.tv_nsec = (mslong % 1000) * 1000000l;
         do {
                 int result = nanosleep(&thiswait, &nextwait);
 
@@ -127,6 +132,44 @@ void ms_sleep(U32 ms)
                 }
         } while (sleep_more);
 }
+
+U32 micro_sleep(U64 us, U32 max_yields)
+{
+    U64 start = get_clock_count();
+    // This is kernel dependent.  Currently, our kernel generates software clock
+    // interrupts at 250 Hz (every 4,000 microseconds).
+    const U64 KERNEL_SLEEP_INTERVAL_US = 4000;
+
+    S32 num_sleep_intervals = (us - (KERNEL_SLEEP_INTERVAL_US >> 1)) / KERNEL_SLEEP_INTERVAL_US;
+    if (num_sleep_intervals > 0)
+    {
+        U64 sleep_time = (num_sleep_intervals * KERNEL_SLEEP_INTERVAL_US) - (KERNEL_SLEEP_INTERVAL_US >> 1);
+        struct timespec thiswait;
+        thiswait.tv_sec = sleep_time / 1000000;
+        thiswait.tv_nsec = (sleep_time % 1000000) * 1000l;
+        _sleep_loop(thiswait);
+    }
+
+    U64 current_clock = get_clock_count();
+    U32 yields = 0;
+    while (    (yields < max_yields)
+            && (current_clock - start < us) )
+    {
+        sched_yield();
+        ++yields;
+        current_clock = get_clock_count();
+    }
+    return yields;
+}
+
+void ms_sleep(U32 ms)
+{
+        long mslong = ms; // tv_nsec is a long
+        struct timespec thiswait;
+        thiswait.tv_sec = ms / 1000;
+        thiswait.tv_nsec = (mslong % 1000) * 1000000l;
+    _sleep_loop(thiswait);
+}
 #else
 # error "architecture not supported"
 #endif
diff --git a/linden/indra/llcommon/lltimer.h b/linden/indra/llcommon/lltimer.h
index 8d94276..766645b 100644
--- a/linden/indra/llcommon/lltimer.h
+++ b/linden/indra/llcommon/lltimer.h
@@ -39,6 +39,8 @@
 
 #include "stdtypes.h"
 
+#include <string>
+#include <list>
 // units conversions
 #ifndef USEC_PER_SEC
     const U32   USEC_PER_SEC    = 1000000;
@@ -115,6 +117,7 @@ void update_clock_frequencies();
 
 // Sleep for milliseconds
 void ms_sleep(U32 ms);
+U32 micro_sleep(U64 us, U32 max_yields = 0xFFFFFFFF);
 
 // Returns the correct UTC time in seconds, like time(NULL).
 // Useful on the viewer, which may have its local clock set wrong.
@@ -184,7 +187,7 @@ protected:
 
 private:
         //list of active timers
-        static std::list<LLEventTimer*> sActiveList;
+        static std::list<LLEventTimer*> sActiveList; // TODO should this be a vector
 };
 
 #endif
diff --git a/linden/indra/llcommon/llversionserver.h b/linden/indra/llcommon/llversionserver.h
index 0b88ce8..2861428 100644
--- a/linden/indra/llcommon/llversionserver.h
+++ b/linden/indra/llcommon/llversionserver.h
@@ -34,8 +34,8 @@
 
 const S32 LL_VERSION_MAJOR = 1;
 const S32 LL_VERSION_MINOR = 24;
-const S32 LL_VERSION_PATCH = 0;
-const S32 LL_VERSION_BUILD = 93453;
+const S32 LL_VERSION_PATCH = 9;
+const S32 LL_VERSION_BUILD = 98650;
 
 const char * const LL_CHANNEL = "Second Life Server";
 
diff --git a/linden/indra/llcommon/llversionviewer.h b/linden/indra/llcommon/llversionviewer.h
index 66462b3..6e7d6ce 100644
--- a/linden/indra/llcommon/llversionviewer.h
+++ b/linden/indra/llcommon/llversionviewer.h
@@ -33,8 +33,8 @@
 #define LL_LLVERSIONVIEWER_H
 
 const S32 LL_VERSION_MAJOR = 1;
-const S32 LL_VERSION_MINOR = 21;
-const S32 LL_VERSION_PATCH = 6;
+const S32 LL_VERSION_MINOR = 22;
+const S32 LL_VERSION_PATCH = 0;
 const S32 LL_VERSION_BUILD = 0;
 
 const char * const LL_CHANNEL = "Second Life Release";