Merge with lindenlab/viewer-development

12 files changed, 535 insertions, 1 deletions

diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt
index 7bad780dd8..478f2fedbd 100644
--- a/indra/llcommon/CMakeLists.txt
+++ b/indra/llcommon/CMakeLists.txt
@@ -70,6 +70,7 @@ set(llcommon_SOURCE_FILES
     llmemorystream.cpp
     llmemtype.cpp
     llmetrics.cpp
+    llmetricperformancetester.cpp
     llmortician.cpp
     lloptioninterface.cpp
     llptrto.cpp 
@@ -186,6 +187,7 @@ set(llcommon_HEADER_FILES
     llmemorystream.h
     llmemtype.h
     llmetrics.h
+    llmetricperformancetester.h
     llmortician.h
     llnametable.h
     lloptioninterface.h
diff --git a/indra/llcommon/llapp.cpp b/indra/llcommon/llapp.cpp
index eebd5ed0a6..39daefd1ad 100644
--- a/indra/llcommon/llapp.cpp
+++ b/indra/llcommon/llapp.cpp
@@ -90,6 +90,10 @@ S32 LL_HEARTBEAT_SIGNAL = (SIGRTMAX >= 0) ? (SIGRTMAX-0) : SIGUSR2;
 // the static application instance
 LLApp* LLApp::sApplication = NULL;
 
+// Allows the generation of core files for post mortem under gdb
+// and disables crashlogger
+BOOL LLApp::sDisableCrashlogger = FALSE; 
+
 // Local flag for whether or not to do logging in signal handlers.
 //static
 BOOL LLApp::sLogInSignal = FALSE;
@@ -461,11 +465,30 @@ bool LLApp::isQuitting()
 	return (APP_STATUS_QUITTING == sStatus);
 }
 
+// static
 bool LLApp::isExiting()
 {
 	return isQuitting() || isError();
 }
 
+void LLApp::disableCrashlogger()
+{
+	// Disable Breakpad exception handler.
+	if (mExceptionHandler != 0)
+	{
+		delete mExceptionHandler;
+		mExceptionHandler = 0;
+	}
+
+	sDisableCrashlogger = TRUE;
+}
+
+// static
+bool LLApp::isCrashloggerDisabled()
+{
+	return (sDisableCrashlogger == TRUE); 
+}
+
 #if !LL_WINDOWS
 // static
 U32 LLApp::getSigChildCount()
@@ -799,6 +822,15 @@ void default_unix_signal_handler(int signum, siginfo_t *info, void *)
 			{
 				llwarns << "Signal handler - Flagging error status and waiting for shutdown" << llendl;
 			}
+									
+			if (LLApp::isCrashloggerDisabled())	// Don't gracefully handle any signal, crash and core for a gdb post mortem
+			{
+				clear_signals();
+				llwarns << "Fatal signal received, not handling the crash here, passing back to operating system" << llendl;
+				raise(signum);
+				return;
+			}		
+			
 			// Flag status to ERROR, so thread_error does its work.
 			LLApp::setError();
 			// Block in the signal handler until somebody says that we're done.
diff --git a/indra/llcommon/llapp.h b/indra/llcommon/llapp.h
index ee1d696829..a536a06ea5 100644
--- a/indra/llcommon/llapp.h
+++ b/indra/llcommon/llapp.h
@@ -189,6 +189,11 @@ public:
 	//
 	virtual bool mainLoop() = 0; // Override for the application main loop.  Needs to at least gracefully notice the QUITTING state and exit.
 
+	//
+	// Crash logging
+	//
+	void disableCrashlogger();				// Let the OS handle the crashes
+	static bool isCrashloggerDisabled();	// Get the here above set value
 
 	//
 	// Application status
@@ -280,6 +285,7 @@ protected:
 	static void setStatus(EAppStatus status);		// Use this to change the application status.
 	static EAppStatus sStatus; // Reflects current application status
 	static BOOL sErrorThreadRunning; // Set while the error thread is running
+	static BOOL sDisableCrashlogger; // Let the OS handle crashes for us.
 
 #if !LL_WINDOWS
 	static LLAtomicU32* sSigChildCount; // Number of SIGCHLDs received.
diff --git a/indra/llcommon/lldictionary.h b/indra/llcommon/lldictionary.h
index 552a805b70..bc3bc3e74a 100644
--- a/indra/llcommon/lldictionary.h
+++ b/indra/llcommon/lldictionary.h
@@ -78,7 +78,9 @@ protected:
 	virtual Index notFound() const
 	{
 		// default is to assert
-		llassert(false);
+		// don't assert -- makes it impossible to work on mesh-development and viewer-development simultaneously
+		//			-- davep 2010.10.29
+		//llassert(false);
 		return Index(-1);
 	}
 	void addEntry(Index index, Entry *entry)
diff --git a/indra/llcommon/llfasttimer_class.cpp b/indra/llcommon/llfasttimer_class.cpp
index c45921cdec..bce87ada96 100644
--- a/indra/llcommon/llfasttimer_class.cpp
+++ b/indra/llcommon/llfasttimer_class.cpp
@@ -56,6 +56,7 @@ bool LLFastTimer::sPauseHistory = 0;
 bool LLFastTimer::sResetHistory = 0;
 LLFastTimer::CurTimerData LLFastTimer::sCurTimerData;
 BOOL LLFastTimer::sLog = FALSE;
+std::string LLFastTimer::sLogName = "";
 BOOL LLFastTimer::sMetricLog = FALSE;
 LLMutex* LLFastTimer::sLogLock = NULL;
 std::queue<LLSD> LLFastTimer::sLogQueue;
diff --git a/indra/llcommon/llfasttimer_class.h b/indra/llcommon/llfasttimer_class.h
index 1158ac5140..eb9789682b 100644
--- a/indra/llcommon/llfasttimer_class.h
+++ b/indra/llcommon/llfasttimer_class.h
@@ -211,6 +211,7 @@ public:
 	static std::queue<LLSD> sLogQueue;
 	static BOOL				sLog;
 	static BOOL				sMetricLog;
+	static std::string		sLogName;
 	static bool 			sPauseHistory;
 	static bool 			sResetHistory;
 	static U64				sTimerCycles;
diff --git a/indra/llcommon/llmetricperformancetester.cpp b/indra/llcommon/llmetricperformancetester.cpp
new file mode 100644
index 0000000000..5fa3a5ea07
--- /dev/null
+++ b/indra/llcommon/llmetricperformancetester.cpp
@@ -0,0 +1,254 @@
+/** 
+ * @file llmetricperformancetester.cpp
+ * @brief LLMetricPerformanceTesterBasic and LLMetricPerformanceTesterWithSession classes implementation
+ *
+ * $LicenseInfo:firstyear=2004&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "indra_constants.h"
+#include "llerror.h"
+#include "llsdserialize.h"
+#include "llstat.h"
+#include "lltreeiterators.h"
+#include "llmetricperformancetester.h"
+
+//----------------------------------------------------------------------------------------------
+// LLMetricPerformanceTesterBasic : static methods and testers management
+//----------------------------------------------------------------------------------------------
+
+LLMetricPerformanceTesterBasic::name_tester_map_t LLMetricPerformanceTesterBasic::sTesterMap ;
+
+/*static*/ 
+void LLMetricPerformanceTesterBasic::cleanClass() 
+{
+	for (name_tester_map_t::iterator iter = sTesterMap.begin() ; iter != sTesterMap.end() ; ++iter)
+	{
+		delete iter->second ;
+	}
+	sTesterMap.clear() ;
+}
+
+/*static*/ 
+BOOL LLMetricPerformanceTesterBasic::addTester(LLMetricPerformanceTesterBasic* tester) 
+{
+	llassert_always(tester != NULL);	
+	std::string name = tester->getTesterName() ;
+	if (getTester(name))
+	{
+		llerrs << "Tester name is already used by some other tester : " << name << llendl ;
+		return FALSE;
+	}
+
+	sTesterMap.insert(std::make_pair(name, tester));
+	return TRUE;
+}
+	
+/*static*/ 
+LLMetricPerformanceTesterBasic* LLMetricPerformanceTesterBasic::getTester(std::string name) 
+{
+	// Check for the requested metric name
+	name_tester_map_t::iterator found_it = sTesterMap.find(name) ;
+	if (found_it != sTesterMap.end())
+	{
+		return found_it->second ;
+	}
+	return NULL ;
+}
+
+/*static*/ 
+// Return TRUE if this metric is requested or if the general default "catch all" metric is requested
+BOOL LLMetricPerformanceTesterBasic::isMetricLogRequested(std::string name)
+{
+	return (LLFastTimer::sMetricLog && ((LLFastTimer::sLogName == name) || (LLFastTimer::sLogName == DEFAULT_METRIC_NAME)));
+}
+
+	
+//----------------------------------------------------------------------------------------------
+// LLMetricPerformanceTesterBasic : Tester instance methods
+//----------------------------------------------------------------------------------------------
+
+LLMetricPerformanceTesterBasic::LLMetricPerformanceTesterBasic(std::string name) : 
+	mName(name),
+	mCount(0)
+{
+	if (mName == std::string())
+	{
+		llerrs << "LLMetricPerformanceTesterBasic construction invalid : Empty name passed to constructor" << llendl ;
+	}
+
+	mValidInstance = LLMetricPerformanceTesterBasic::addTester(this) ;
+}
+
+LLMetricPerformanceTesterBasic::~LLMetricPerformanceTesterBasic() 
+{
+}
+
+void LLMetricPerformanceTesterBasic::preOutputTestResults(LLSD* sd) 
+{
+	incrementCurrentCount() ;
+	(*sd)[getCurrentLabelName()]["Name"] = mName ;
+}
+
+void LLMetricPerformanceTesterBasic::postOutputTestResults(LLSD* sd)
+{
+	LLMutexLock lock(LLFastTimer::sLogLock);
+	LLFastTimer::sLogQueue.push((*sd));
+}
+
+void LLMetricPerformanceTesterBasic::outputTestResults() 
+{
+	LLSD sd;
+
+	preOutputTestResults(&sd) ; 
+	outputTestRecord(&sd) ;
+	postOutputTestResults(&sd) ;
+}
+
+void LLMetricPerformanceTesterBasic::addMetric(std::string str)
+{
+	mMetricStrings.push_back(str) ;
+}
+
+/*virtual*/ 
+void LLMetricPerformanceTesterBasic::analyzePerformance(std::ofstream* os, LLSD* base, LLSD* current) 
+{
+	resetCurrentCount() ;
+
+	std::string current_label = getCurrentLabelName();
+	BOOL in_base = (*base).has(current_label) ;
+	BOOL in_current = (*current).has(current_label) ;
+
+	while(in_base || in_current)
+	{
+		LLSD::String label = current_label ;		
+
+		if(in_base && in_current)
+		{				
+			*os << llformat("%s\n", label.c_str()) ;
+
+			for(U32 index = 0 ; index < mMetricStrings.size() ; index++)
+			{
+				switch((*current)[label][ mMetricStrings[index] ].type())
+				{
+				case LLSD::TypeInteger:
+					compareTestResults(os, mMetricStrings[index], 
+						(S32)((*base)[label][ mMetricStrings[index] ].asInteger()), (S32)((*current)[label][ mMetricStrings[index] ].asInteger())) ;
+					break ;
+				case LLSD::TypeReal:
+					compareTestResults(os, mMetricStrings[index], 
+						(F32)((*base)[label][ mMetricStrings[index] ].asReal()), (F32)((*current)[label][ mMetricStrings[index] ].asReal())) ;
+					break;
+				default:
+					llerrs << "unsupported metric " << mMetricStrings[index] << " LLSD type: " << (S32)(*current)[label][ mMetricStrings[index] ].type() << llendl ;
+				}
+			}	
+		}
+
+		incrementCurrentCount();
+		current_label = getCurrentLabelName();
+		in_base = (*base).has(current_label) ;
+		in_current = (*current).has(current_label) ;
+	}
+}
+
+/*virtual*/ 
+void LLMetricPerformanceTesterBasic::compareTestResults(std::ofstream* os, std::string metric_string, S32 v_base, S32 v_current) 
+{
+	*os << llformat(" ,%s, %d, %d, %d, %.4f\n", metric_string.c_str(), v_base, v_current, 
+						v_current - v_base, (v_base != 0) ? 100.f * v_current / v_base : 0) ;
+}
+
+/*virtual*/ 
+void LLMetricPerformanceTesterBasic::compareTestResults(std::ofstream* os, std::string metric_string, F32 v_base, F32 v_current) 
+{
+	*os << llformat(" ,%s, %.4f, %.4f, %.4f, %.4f\n", metric_string.c_str(), v_base, v_current,						
+						v_current - v_base, (fabs(v_base) > 0.0001f) ? 100.f * v_current / v_base : 0.f ) ;
+}
+
+//----------------------------------------------------------------------------------------------
+// LLMetricPerformanceTesterWithSession
+//----------------------------------------------------------------------------------------------
+
+LLMetricPerformanceTesterWithSession::LLMetricPerformanceTesterWithSession(std::string name) : 
+	LLMetricPerformanceTesterBasic(name),
+	mBaseSessionp(NULL),
+	mCurrentSessionp(NULL)
+{
+}
+
+LLMetricPerformanceTesterWithSession::~LLMetricPerformanceTesterWithSession()
+{
+	if (mBaseSessionp)
+	{
+		delete mBaseSessionp ;
+		mBaseSessionp = NULL ;
+	}
+	if (mCurrentSessionp)
+	{
+		delete mCurrentSessionp ;
+		mCurrentSessionp = NULL ;
+	}
+}
+
+/*virtual*/ 
+void LLMetricPerformanceTesterWithSession::analyzePerformance(std::ofstream* os, LLSD* base, LLSD* current) 
+{
+	// Load the base session
+	resetCurrentCount() ;
+	mBaseSessionp = loadTestSession(base) ;
+
+	// Load the current session
+	resetCurrentCount() ;
+	mCurrentSessionp = loadTestSession(current) ;
+
+	if (!mBaseSessionp || !mCurrentSessionp)
+	{
+		llerrs << "Error loading test sessions." << llendl ;
+	}
+
+	// Compare
+	compareTestSessions(os) ;
+
+	// Release memory
+	if (mBaseSessionp)
+	{
+		delete mBaseSessionp ;
+		mBaseSessionp = NULL ;
+	}
+	if (mCurrentSessionp)
+	{
+		delete mCurrentSessionp ;
+		mCurrentSessionp = NULL ;
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------
+// LLTestSession
+//----------------------------------------------------------------------------------------------
+
+LLMetricPerformanceTesterWithSession::LLTestSession::~LLTestSession() 
+{
+}
+
diff --git a/indra/llcommon/llmetricperformancetester.h b/indra/llcommon/llmetricperformancetester.h
new file mode 100644
index 0000000000..925010ac96
--- /dev/null
+++ b/indra/llcommon/llmetricperformancetester.h
@@ -0,0 +1,206 @@
+/** 
+ * @file llmetricperformancetester.h 
+ * @brief LLMetricPerformanceTesterBasic and LLMetricPerformanceTesterWithSession classes definition
+ *
+ * $LicenseInfo:firstyear=2004&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_METRICPERFORMANCETESTER_H 
+#define LL_METRICPERFORMANCETESTER_H 
+
+const std::string DEFAULT_METRIC_NAME("metric");
+
+/**
+ * @class LLMetricPerformanceTesterBasic
+ * @brief Performance Metric Base Class
+ */
+class LL_COMMON_API LLMetricPerformanceTesterBasic
+{
+public:
+	/**
+	 * @brief Creates a basic tester instance.
+	 * @param[in] name - Unique string identifying this tester instance.
+	 */
+	LLMetricPerformanceTesterBasic(std::string name);
+	virtual ~LLMetricPerformanceTesterBasic();
+
+	/**
+	 * @return Returns true if the instance has been added to the tester map.
+	 * Need to be tested after creation of a tester instance so to know if the tester is correctly handled.
+	 * A tester might not be added to the map if another tester with the same name already exists.
+	 */
+	BOOL isValid() const { return mValidInstance; }
+
+	/**
+	 * @brief Write a set of test results to the log LLSD.
+	 */
+	void outputTestResults() ;
+
+	/**
+	 * @brief Compare the test results.
+	 * By default, compares the test results against the baseline one by one, item by item, 
+	 * in the increasing order of the LLSD record counter, starting from the first one.
+	 */
+	virtual void analyzePerformance(std::ofstream* os, LLSD* base, LLSD* current) ;
+
+	/**
+	 * @return Returns the number of the test metrics in this tester instance.
+	 */
+	S32 getNumberOfMetrics() const { return mMetricStrings.size() ;}
+	/**
+	 * @return Returns the metric name at index
+	 * @param[in] index - Index on the list of metrics managed by this tester instance.
+	 */
+	std::string getMetricName(S32 index) const { return mMetricStrings[index] ;}
+
+protected:
+	/**
+	 * @return Returns the name of this tester instance.
+	 */
+	std::string getTesterName() const { return mName ;}
+
+	/**
+	 * @brief Insert a new metric to be managed by this tester instance.
+	 * @param[in] str - Unique string identifying the new metric.
+	 */
+	void addMetric(std::string str) ;
+
+	/**
+	 * @brief Compare test results, provided in 2 flavors: compare integers and compare floats.
+	 * @param[out] os - Formatted output string holding the compared values.
+	 * @param[in] metric_string - Name of the metric.
+	 * @param[in] v_base - Base value of the metric.
+	 * @param[in] v_current - Current value of the metric.
+	 */
+	virtual void compareTestResults(std::ofstream* os, std::string metric_string, S32 v_base, S32 v_current) ;
+	virtual void compareTestResults(std::ofstream* os, std::string metric_string, F32 v_base, F32 v_current) ;
+
+	/**
+	 * @brief Reset internal record count. Count starts with 1.
+	 */
+	void resetCurrentCount() { mCount = 1; }
+	/**
+	 * @brief Increment internal record count.
+	 */
+	void incrementCurrentCount() { mCount++; }
+	/**
+	 * @return Returns the label to be used for the current count. It's "TesterName"-"Count".
+	 */
+	std::string getCurrentLabelName() const { return llformat("%s-%d", mName.c_str(), mCount) ;}
+
+	/**
+	 * @brief Write a test record to the LLSD. Implementers need to overload this method.
+	 * @param[out] sd - The LLSD record to store metric data into.
+	 */
+	virtual void outputTestRecord(LLSD* sd) = 0 ;
+
+private:
+	void preOutputTestResults(LLSD* sd) ;
+	void postOutputTestResults(LLSD* sd) ;
+
+	std::string mName ;							// Name of this tester instance
+	S32 mCount ;								// Current record count
+	BOOL mValidInstance;						// TRUE if the instance is managed by the map
+	std::vector< std::string > mMetricStrings ; // Metrics strings
+
+// Static members managing the collection of testers
+public:	
+	// Map of all the tester instances in use
+	typedef std::map< std::string, LLMetricPerformanceTesterBasic* > name_tester_map_t;	
+	static name_tester_map_t sTesterMap ;
+
+	/**
+	 * @return Returns a pointer to the tester
+	 * @param[in] name - Name of the tester instance queried.
+	 */
+	static LLMetricPerformanceTesterBasic* getTester(std::string name) ;
+	
+	/**
+	 * @return Returns TRUE if that metric *or* the default catch all metric has been requested to be logged
+	 * @param[in] name - Name of the tester queried.
+	 */
+	static BOOL isMetricLogRequested(std::string name);
+	
+	/**
+	 * @return Returns TRUE if there's a tester defined, FALSE otherwise.
+	 */
+	static BOOL hasMetricPerformanceTesters() { return !sTesterMap.empty() ;}
+	/**
+	 * @brief Delete all testers and reset the tester map
+	 */
+	static void cleanClass() ;
+
+private:
+	// Add a tester to the map. Returns false if adding fails.
+	static BOOL addTester(LLMetricPerformanceTesterBasic* tester) ;
+};
+
+/**
+ * @class LLMetricPerformanceTesterWithSession
+ * @brief Performance Metric Class with custom session 
+ */
+class LL_COMMON_API LLMetricPerformanceTesterWithSession : public LLMetricPerformanceTesterBasic
+{
+public:
+	/**
+	 * @param[in] name - Unique string identifying this tester instance.
+	 */
+	LLMetricPerformanceTesterWithSession(std::string name);
+	virtual ~LLMetricPerformanceTesterWithSession();
+
+	/**
+	 * @brief Compare the test results.
+	 * This will be loading the base and current sessions and compare them using the virtual 
+	 * abstract methods loadTestSession() and compareTestSessions()
+	 */
+	virtual void analyzePerformance(std::ofstream* os, LLSD* base, LLSD* current) ;
+
+protected:
+	/**
+	 * @class LLMetricPerformanceTesterWithSession::LLTestSession
+	 * @brief Defines an interface for the two abstract virtual functions loadTestSession() and compareTestSessions()
+	 */
+	class LL_COMMON_API LLTestSession
+		{
+		public:
+			virtual ~LLTestSession() ;
+		};
+
+	/**
+	 * @brief Convert an LLSD log into a test session.
+	 * @param[in] log - The LLSD record
+	 * @return Returns the record as a test session
+	 */
+	virtual LLMetricPerformanceTesterWithSession::LLTestSession* loadTestSession(LLSD* log) = 0;
+
+	/**
+	 * @brief Compare the base session and the target session. Assumes base and current sessions have been loaded.
+	 * @param[out] os - The comparison result as a standard stream
+	 */
+	virtual void compareTestSessions(std::ofstream* os) = 0;
+
+	LLTestSession* mBaseSessionp;
+	LLTestSession* mCurrentSessionp;
+};
+
+#endif
+
diff --git a/indra/llcommon/llprocesslauncher.cpp b/indra/llcommon/llprocesslauncher.cpp
index 99308c94e7..81e5f8820d 100644
--- a/indra/llcommon/llprocesslauncher.cpp
+++ b/indra/llcommon/llprocesslauncher.cpp
@@ -58,6 +58,11 @@ void LLProcessLauncher::setWorkingDirectory(const std::string &dir)
 	mWorkingDir = dir;
 }
 
+const std::string& LLProcessLauncher::getExecutable() const
+{
+	return mExecutable;
+}
+
 void LLProcessLauncher::clearArguments()
 {
 	mLaunchArguments.clear();
diff --git a/indra/llcommon/llprocesslauncher.h b/indra/llcommon/llprocesslauncher.h
index 479aeb664a..954c249147 100644
--- a/indra/llcommon/llprocesslauncher.h
+++ b/indra/llcommon/llprocesslauncher.h
@@ -47,6 +47,8 @@ public:
 	void setExecutable(const std::string &executable);
 	void setWorkingDirectory(const std::string &dir);
 
+	const std::string& getExecutable() const;
+
 	void clearArguments();
 	void addArgument(const std::string &arg);
 	void addArgument(const char *arg);
diff --git a/indra/llcommon/llsys.cpp b/indra/llcommon/llsys.cpp
index 00c94404d4..10cdc7087b 100644
--- a/indra/llcommon/llsys.cpp
+++ b/indra/llcommon/llsys.cpp
@@ -635,6 +635,26 @@ U32 LLMemoryInfo::getPhysicalMemoryClamped() const
 	}
 }
 
+//static
+void LLMemoryInfo::getAvailableMemoryKB(U32& avail_physical_mem_kb, U32& avail_virtual_mem_kb)
+{
+#if LL_WINDOWS
+	MEMORYSTATUSEX state;
+	state.dwLength = sizeof(state);
+	GlobalMemoryStatusEx(&state);
+
+	avail_physical_mem_kb = (U32)(state.ullAvailPhys/1024) ;
+	avail_virtual_mem_kb = (U32)(state.ullAvailVirtual/1024) ;
+
+#else
+	//do not know how to collect available memory info for other systems.
+	//leave it blank here for now.
+
+	avail_physical_mem_kb = -1 ;
+	avail_virtual_mem_kb = -1 ;
+#endif
+}
+
 void LLMemoryInfo::stream(std::ostream& s) const
 {
 #if LL_WINDOWS
diff --git a/indra/llcommon/llsys.h b/indra/llcommon/llsys.h
index 39af74e5c8..41a4f25000 100644
--- a/indra/llcommon/llsys.h
+++ b/indra/llcommon/llsys.h
@@ -114,6 +114,9 @@ public:
 	**  be returned.
 	*/
 	U32 getPhysicalMemoryClamped() const; ///< Memory size in clamped bytes
+
+	//get the available memory infomation in KiloBytes.
+	static void getAvailableMemoryKB(U32& avail_physical_mem_kb, U32& avail_virtual_mem_kb);
 };