11 files changed, 229 insertions, 55 deletions

diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt
index 60d4cfe6d3..6f39aba976 100644
--- a/indra/llcommon/CMakeLists.txt
+++ b/indra/llcommon/CMakeLists.txt
@@ -117,7 +117,7 @@ set(llcommon_HEADER_FILES
     indra_constants.h
     linden_common.h
     linked_lists.h
-    llaccountingquota.h
+    llaccountingcost.h
     llallocator.h
     llallocator_heap_profile.h
     llagentconstants.h
diff --git a/indra/llcommon/llaccountingquota.h b/indra/llcommon/llaccountingcost.h
index 140333de07..0ef3b50c6d 100644
--- a/indra/llcommon/llaccountingquota.h
+++ b/indra/llcommon/llaccountingcost.h
@@ -1,5 +1,5 @@
 /** 
- * @file llaccountingquota.h
+ * @file llaccountingcost.h
  * @
  *
  * $LicenseInfo:firstyear=2001&license=viewerlgpl$
@@ -58,22 +58,28 @@ struct ParcelQuota
 	F32 mParcelCapacity;
 };
 
-struct SelectionQuota
+//SelectionQuota atm does not require a id
+struct SelectionCost
 {
-	SelectionQuota( LLUUID localId, F32 renderCost, F32 physicsCost, F32 networkCost, F32 simulationCost )
-	: mLocalId( localId)
-	, mRenderCost( renderCost )
-	, mPhysicsCost( physicsCost )
+	SelectionCost( /*LLTransactionID transactionId, */ F32 physicsCost, F32 networkCost, F32 simulationCost )
+	//: mTransactionId( transactionId)
+	: mPhysicsCost( physicsCost )
 	, mNetworkCost( networkCost )
 	, mSimulationCost( simulationCost )
 	{
 	}
-	SelectionQuota() {}
+	SelectionCost()
+	: mPhysicsCost( 0.0f )
+	, mNetworkCost( 0.0f )
+	, mSimulationCost( 0.0f )
+	{}
 	
-	F32 mRenderCost, mPhysicsCost, mNetworkCost, mSimulationCost;	
-	LLUUID mLocalId;
+	F32 mPhysicsCost, mNetworkCost, mSimulationCost;	
+	//LLTransactionID mTransactionId;
 };
 
+typedef enum { Roots = 0 , Prims } eSelectionType;
+
 #endif
 
 
diff --git a/indra/llcommon/lleventapi.cpp b/indra/llcommon/lleventapi.cpp
index 4270c8b511..ff5459c1eb 100644
--- a/indra/llcommon/lleventapi.cpp
+++ b/indra/llcommon/lleventapi.cpp
@@ -34,6 +34,7 @@
 // std headers
 // external library headers
 // other Linden headers
+#include "llerror.h"
 
 LLEventAPI::LLEventAPI(const std::string& name, const std::string& desc, const std::string& field):
     lbase(name, field),
@@ -45,3 +46,32 @@ LLEventAPI::LLEventAPI(const std::string& name, const std::string& desc, const s
 LLEventAPI::~LLEventAPI()
 {
 }
+
+LLEventAPI::Response::Response(const LLSD& seed, const LLSD& request, const LLSD::String& replyKey):
+    mResp(seed),
+    mReq(request),
+    mKey(replyKey)
+{}
+
+LLEventAPI::Response::~Response()
+{
+    // When you instantiate a stack Response object, if the original
+    // request requested a reply, send it when we leave this block, no
+    // matter how.
+    sendReply(mResp, mReq, mKey);
+}
+
+void LLEventAPI::Response::warn(const std::string& warning)
+{
+    LL_WARNS("LLEventAPI::Response") << warning << LL_ENDL;
+    mResp["warnings"].append(warning);
+}
+
+void LLEventAPI::Response::error(const std::string& error)
+{
+    // Use LL_WARNS rather than LL_ERROR: we don't want the viewer to shut
+    // down altogether.
+    LL_WARNS("LLEventAPI::Response") << error << LL_ENDL;
+
+    mResp["error"] = error;
+}
diff --git a/indra/llcommon/lleventapi.h b/indra/llcommon/lleventapi.h
index d75d521e8e..1a37d780b6 100644
--- a/indra/llcommon/lleventapi.h
+++ b/indra/llcommon/lleventapi.h
@@ -76,6 +76,89 @@ public:
         LLEventDispatcher::add(name, desc, callable, required);
     }
 
+    /**
+     * Instantiate a Response object in any LLEventAPI subclass method that
+     * wants to guarantee a reply (if requested) will be sent on exit from the
+     * method. The reply will be sent if request.has(@a replyKey), default
+     * "reply". If specified, the value of request[replyKey] is the name of
+     * the LLEventPump on which to send the reply. Conventionally you might
+     * code something like:
+     *
+     * @code
+     * void MyEventAPI::someMethod(const LLSD& request)
+     * {
+     *     // Send a reply event as long as request.has("reply")
+     *     Response response(LLSD(), request);
+     *     // ...
+     *     // will be sent in reply event
+     *     response["somekey"] = some_data;
+     * }
+     * @endcode
+     */
+    class LL_COMMON_API Response
+    {
+    public:
+        /**
+         * Instantiating a Response object in an LLEventAPI subclass method
+         * ensures that, if desired, a reply event will be sent.
+         *
+         * @a seed is the initial reply LLSD that will be further decorated before
+         * being sent as the reply
+         *
+         * @a request is the incoming request LLSD; we particularly care about
+         * [replyKey] and ["reqid"]
+         *
+         * @a replyKey [default "reply"] is the string name of the LLEventPump
+         * on which the caller wants a reply. If <tt>(!
+         * request.has(replyKey))</tt>, no reply will be sent.
+         */
+        Response(const LLSD& seed, const LLSD& request, const LLSD::String& replyKey="reply");
+        ~Response();
+
+        /**
+         * @code
+         * if (some condition)
+         * {
+         *     response.warn("warnings are logged and collected in [\"warnings\"]");
+         * }
+         * @endcode
+         */
+        void warn(const std::string& warning);
+        /**
+         * @code
+         * if (some condition isn't met)
+         * {
+         *     // In a function returning void, you can validly 'return
+         *     // expression' if the expression is itself of type void. But
+         *     // returning is up to you; response.error() has no effect on
+         *     // flow of control.
+         *     return response.error("error message, logged and also sent as [\"error\"]");
+         * }
+         * @endcode
+         */
+        void error(const std::string& error);
+
+        /**
+         * set other keys...
+         *
+         * @code
+         * // set any attributes you want to be sent in the reply
+         * response["info"] = some_value;
+         * // ...
+         * response["ok"] = went_well;
+         * @endcode
+         */
+        LLSD& operator[](const LLSD::String& key) { return mResp[key]; }
+		
+		 /**
+		 * set the response to the given data
+		 */
+		void setResponse(LLSD const & response){ mResp = response; }
+
+        LLSD mResp, mReq;
+        LLSD::String mKey;
+    };
+
 private:
     std::string mDesc;
 };
diff --git a/indra/llcommon/llevents.cpp b/indra/llcommon/llevents.cpp
index ff03506e84..db1ea4792b 100644
--- a/indra/llcommon/llevents.cpp
+++ b/indra/llcommon/llevents.cpp
@@ -591,6 +591,17 @@ void LLReqID::stamp(LLSD& response) const
 
 bool sendReply(const LLSD& reply, const LLSD& request, const std::string& replyKey)
 {
+    // If the original request has no value for replyKey, it's pointless to
+    // construct or send a reply event: on which LLEventPump should we send
+    // it? Allow that to be optional: if the caller wants to require replyKey,
+    // it can so specify when registering the operation method.
+    if (! request.has(replyKey))
+    {
+        return false;
+    }
+
+    // Here the request definitely contains replyKey; reasonable to proceed.
+
     // Copy 'reply' to modify it.
     LLSD newreply(reply);
     // Get the ["reqid"] element from request
diff --git a/indra/llcommon/llfasttimer_class.cpp b/indra/llcommon/llfasttimer_class.cpp
index ebb5961c91..463f558c2c 100644
--- a/indra/llcommon/llfasttimer_class.cpp
+++ b/indra/llcommon/llfasttimer_class.cpp
@@ -303,14 +303,15 @@ LLFastTimer::NamedTimer::~NamedTimer()
 
 std::string LLFastTimer::NamedTimer::getToolTip(S32 history_idx)
 {
+	F64 ms_multiplier = 1000.0 / (F64)LLFastTimer::countsPerSecond();
 	if (history_idx < 0)
 	{
-		// by default, show average number of calls
-		return llformat("%s (%d calls)", getName().c_str(), (S32)getCallAverage());
+		// by default, show average number of call
+		return llformat("%s (%d ms, %d calls)", getName().c_str(), (S32)(getCountAverage() * ms_multiplier), (S32)getCallAverage());
 	}
 	else
 	{
-		return llformat("%s (%d calls)", getName().c_str(), (S32)getHistoricalCalls(history_idx));
+		return llformat("%s (%d ms, %d calls)", getName().c_str(), (S32)(getHistoricalCount(history_idx) * ms_multiplier), (S32)getHistoricalCalls(history_idx));
 	}
 }
 
@@ -693,17 +694,7 @@ void LLFastTimer::nextFrame()
 		llinfos << "Slow frame, fast timers inaccurate" << llendl;
 	}
 
-	if (sPauseHistory)
-	{
-		sResetHistory = true;
-	}
-	else if (sResetHistory)
-	{
-		sLastFrameIndex = 0;
-		sCurFrameIndex = 0;
-		sResetHistory = false;
-	}
-	else // not paused
+	if (!sPauseHistory)
 	{
 		NamedTimer::processTimes();
 		sLastFrameIndex = sCurFrameIndex++;
diff --git a/indra/llcommon/llfasttimer_class.h b/indra/llcommon/llfasttimer_class.h
index 827747f0c6..f481e968a6 100644
--- a/indra/llcommon/llfasttimer_class.h
+++ b/indra/llcommon/llfasttimer_class.h
@@ -66,7 +66,7 @@ public:
 	public:
 		~NamedTimer();
 
-		enum { HISTORY_NUM = 60 };
+		enum { HISTORY_NUM = 300 };
 
 		const std::string& getName() const { return mName; }
 		NamedTimer* getParent() const { return mParent; }
diff --git a/indra/llcommon/llmemory.cpp b/indra/llcommon/llmemory.cpp
index 8c02ad8290..3b27a1639a 100644
--- a/indra/llcommon/llmemory.cpp
+++ b/indra/llcommon/llmemory.cpp
@@ -165,33 +165,60 @@ void LLMemory::logMemoryInfo(BOOL update)
 	llinfos << "Current allocated page size (KB): " << sAllocatedPageSizeInKB << llendl ;
 	llinfos << "Current availabe physical memory(KB): " << sAvailPhysicalMemInKB << llendl ;
 	llinfos << "Current max usable memory(KB): " << sMaxPhysicalMemInKB << llendl ;
+
+	llinfos << "--- private pool information -- " << llendl ;
+	llinfos << "Total reserved (KB): " << LLPrivateMemoryPoolManager::getInstance()->mTotalReservedSize / 1024 << llendl ;
+	llinfos << "Total allocated (KB): " << LLPrivateMemoryPoolManager::getInstance()->mTotalAllocatedSize / 1024 << llendl ;
 }
 
 //return 0: everything is normal;
 //return 1: the memory pool is low, but not in danger;
 //return -1: the memory pool is in danger, is about to crash.
 //static 
-S32 LLMemory::isMemoryPoolLow()
+bool LLMemory::isMemoryPoolLow()
 {
 	static const U32 LOW_MEMEOY_POOL_THRESHOLD_KB = 64 * 1024 ; //64 MB for emergency use
+	const static U32 MAX_SIZE_CHECKED_MEMORY_BLOCK = 64 * 1024 * 1024 ; //64 MB
+	static void* last_reserved_address = NULL ;
 
 	if(!sEnableMemoryFailurePrevention)
 	{
-		return 0 ; //no memory failure prevention.
+		return false ; //no memory failure prevention.
 	}
 
 	if(sAvailPhysicalMemInKB < (LOW_MEMEOY_POOL_THRESHOLD_KB >> 2)) //out of physical memory
 	{
-		return -1 ;
+		return true ;
 	}
 
 	if(sAllocatedPageSizeInKB + (LOW_MEMEOY_POOL_THRESHOLD_KB >> 2) > sMaxHeapSizeInKB) //out of virtual address space.
 	{
-		return -1 ;
+		return true ;
 	}
 
-	return (S32)(sAvailPhysicalMemInKB < LOW_MEMEOY_POOL_THRESHOLD_KB || 
+	bool is_low = (S32)(sAvailPhysicalMemInKB < LOW_MEMEOY_POOL_THRESHOLD_KB || 
 		sAllocatedPageSizeInKB + LOW_MEMEOY_POOL_THRESHOLD_KB > sMaxHeapSizeInKB) ;
+
+	//check the virtual address space fragmentation
+	if(!is_low)
+	{
+		if(!last_reserved_address)
+		{
+			last_reserved_address = LLMemory::tryToAlloc(last_reserved_address, MAX_SIZE_CHECKED_MEMORY_BLOCK) ;
+		}
+		else
+		{
+			last_reserved_address = LLMemory::tryToAlloc(last_reserved_address, MAX_SIZE_CHECKED_MEMORY_BLOCK) ;
+			if(!last_reserved_address) //failed, try once more
+			{
+				last_reserved_address = LLMemory::tryToAlloc(last_reserved_address, MAX_SIZE_CHECKED_MEMORY_BLOCK) ;
+			}
+		}
+
+		is_low = !last_reserved_address ; //allocation failed
+	}
+
+	return is_low ;
 }
 
 //static 
@@ -1289,15 +1316,13 @@ U16 LLPrivateMemoryPool::LLMemoryChunk::getPageLevel(U32 size)
 //--------------------------------------------------------------------
 const U32 CHUNK_SIZE = 4 << 20 ; //4 MB
 const U32 LARGE_CHUNK_SIZE = 4 * CHUNK_SIZE ; //16 MB
-LLPrivateMemoryPool::LLPrivateMemoryPool(S32 type) :
+LLPrivateMemoryPool::LLPrivateMemoryPool(S32 type, U32 max_pool_size) :
 	mMutexp(NULL),	
 	mReservedPoolSize(0),
 	mHashFactor(1),
-	mType(type)
+	mType(type),
+	mMaxPoolSize(max_pool_size)
 {
-	const U32 MAX_POOL_SIZE = 256 * 1024 * 1024 ; //256 MB
-
-	mMaxPoolSize = MAX_POOL_SIZE ;
 	if(type == STATIC_THREADED || type == VOLATILE_THREADED)
 	{
 		mMutexp = new LLMutex ;
@@ -1362,16 +1387,31 @@ char* LLPrivateMemoryPool::allocate(U32 size)
 				chunk = chunk->mNext ;
 			}
 		}
-
-		chunk = addChunk(chunk_idx) ;
-		if(chunk)
+		else
 		{
-			p = chunk->allocate(size) ;
+			chunk = addChunk(chunk_idx) ;
+			if(chunk)
+			{
+				p = chunk->allocate(size) ;
+			}
 		}
 	}
 
 	unlock() ;
 
+	if(!p) //to get memory from the private pool failed, try the heap directly
+	{
+		static bool to_log = true ;
+		
+		if(to_log)
+		{
+			llwarns << "The memory pool overflows, now using heap directly!" << llendl ;
+			to_log = false ;
+		}
+
+		return (char*)malloc(size) ;
+	}
+
 	return p ;
 }
 
@@ -1472,7 +1512,7 @@ void  LLPrivateMemoryPool::destroyPool()
 	unlock() ;
 }
 
-void  LLPrivateMemoryPool::checkSize(U32 asked_size)
+bool LLPrivateMemoryPool::checkSize(U32 asked_size)
 {
 	if(mReservedPoolSize + asked_size > mMaxPoolSize)
 	{
@@ -1480,8 +1520,12 @@ void  LLPrivateMemoryPool::checkSize(U32 asked_size)
 		llinfos << "Total reserved size: " << mReservedPoolSize + asked_size << llendl ;
 		llinfos << "Total_allocated Size: " << getTotalAllocatedSize() << llendl ;
 
-		llerrs << "The pool is overflowing..." << llendl ;
+		//llerrs << "The pool is overflowing..." << llendl ;
+
+		return false ;
 	}
+
+	return true ;
 }
 
 LLPrivateMemoryPool::LLMemoryChunk* LLPrivateMemoryPool::addChunk(S32 chunk_index)
@@ -1501,7 +1545,11 @@ LLPrivateMemoryPool::LLMemoryChunk* LLPrivateMemoryPool::addChunk(S32 chunk_inde
 			MAX_SLOT_SIZES[chunk_index], MIN_BLOCK_SIZES[chunk_index], MAX_BLOCK_SIZES[chunk_index]) ;
 	}
 
-	checkSize(preferred_size + overhead) ;
+	if(!checkSize(preferred_size + overhead))
+	{
+		return NULL ;
+	}
+
 	mReservedPoolSize += preferred_size + overhead ;
 
 	char* buffer = (char*)malloc(preferred_size + overhead) ;
@@ -1593,7 +1641,7 @@ LLPrivateMemoryPool::LLMemoryChunk* LLPrivateMemoryPool::findChunk(const char* a
 
 void LLPrivateMemoryPool::addToHashTable(LLMemoryChunk* chunk) 
 {
-	static const U16 HASH_FACTORS[] = {41, 83, 193, 317, 419, 523, 0xFFFF}; 
+	static const U16 HASH_FACTORS[] = {41, 83, 193, 317, 419, 523, 719, 997, 1523, 0xFFFF}; 
 	
 	U16 i ;
 	if(mChunkHashList.empty())
@@ -1774,7 +1822,7 @@ void LLPrivateMemoryPool::LLChunkHashElement::remove(LLPrivateMemoryPool::LLMemo
 //--------------------------------------------------------------------
 LLPrivateMemoryPoolManager* LLPrivateMemoryPoolManager::sInstance = NULL ;
 
-LLPrivateMemoryPoolManager::LLPrivateMemoryPoolManager(BOOL enabled) 
+LLPrivateMemoryPoolManager::LLPrivateMemoryPoolManager(BOOL enabled, U32 max_pool_size) 
 {
 	mPoolList.resize(LLPrivateMemoryPool::MAX_TYPES) ;
 
@@ -1784,6 +1832,9 @@ LLPrivateMemoryPoolManager::LLPrivateMemoryPoolManager(BOOL enabled)
 	}
 
 	mPrivatePoolEnabled = enabled ;
+
+	const U32 MAX_POOL_SIZE = 256 * 1024 * 1024 ; //256 MB
+	mMaxPrivatePoolSize = llmax(max_pool_size, MAX_POOL_SIZE) ;
 }
 
 LLPrivateMemoryPoolManager::~LLPrivateMemoryPoolManager() 
@@ -1826,11 +1877,11 @@ LLPrivateMemoryPoolManager::~LLPrivateMemoryPoolManager()
 }
 
 //static 
-void LLPrivateMemoryPoolManager::initClass(BOOL enabled) 
+void LLPrivateMemoryPoolManager::initClass(BOOL enabled, U32 max_pool_size) 
 {
 	llassert_always(!sInstance) ;
 
-	sInstance = new LLPrivateMemoryPoolManager(enabled) ;
+	sInstance = new LLPrivateMemoryPoolManager(enabled, max_pool_size) ;
 }
 
 //static 
@@ -1862,7 +1913,7 @@ LLPrivateMemoryPool* LLPrivateMemoryPoolManager::newPool(S32 type)
 
 	if(!mPoolList[type])
 	{
-		mPoolList[type] = new LLPrivateMemoryPool(type) ;
+		mPoolList[type] = new LLPrivateMemoryPool(type, mMaxPrivatePoolSize) ;
 	}
 
 	return mPoolList[type] ;
diff --git a/indra/llcommon/llmemory.h b/indra/llcommon/llmemory.h
index db753f0d8b..6967edd7e7 100644
--- a/indra/llcommon/llmemory.h
+++ b/indra/llcommon/llmemory.h
@@ -122,7 +122,7 @@ public:
 	static void initMaxHeapSizeGB(F32 max_heap_size_gb, BOOL prevent_heap_failure);
 	static void updateMemoryInfo() ;
 	static void logMemoryInfo(BOOL update = FALSE);
-	static S32  isMemoryPoolLow();
+	static bool isMemoryPoolLow();
 
 	static U32 getAvailableMemKB() ;
 	static U32 getMaxMemKB() ;
@@ -303,7 +303,7 @@ public:
 	} ;
 
 private:
-	LLPrivateMemoryPool(S32 type) ;
+	LLPrivateMemoryPool(S32 type, U32 max_pool_size) ;
 	~LLPrivateMemoryPool() ;
 
 	char *allocate(U32 size) ;
@@ -320,7 +320,7 @@ private:
 	void unlock() ;	
 	S32 getChunkIndex(U32 size) ;
 	LLMemoryChunk*  addChunk(S32 chunk_index) ;
-	void checkSize(U32 asked_size) ;
+	bool checkSize(U32 asked_size) ;
 	void removeChunk(LLMemoryChunk* chunk) ;
 	U16  findHashKey(const char* addr);
 	void addToHashTable(LLMemoryChunk* chunk) ;
@@ -383,12 +383,12 @@ private:
 class LL_COMMON_API LLPrivateMemoryPoolManager
 {
 private:
-	LLPrivateMemoryPoolManager(BOOL enabled) ;
+	LLPrivateMemoryPoolManager(BOOL enabled, U32 max_pool_size) ;
 	~LLPrivateMemoryPoolManager() ;
 
 public:	
 	static LLPrivateMemoryPoolManager* getInstance() ;
-	static void initClass(BOOL enabled) ;
+	static void initClass(BOOL enabled, U32 pool_size) ;
 	static void destroyClass() ;
 
 	LLPrivateMemoryPool* newPool(S32 type) ;
@@ -398,6 +398,7 @@ private:
 	static LLPrivateMemoryPoolManager* sInstance ;
 	std::vector<LLPrivateMemoryPool*> mPoolList ;
 	BOOL mPrivatePoolEnabled;
+	U32  mMaxPrivatePoolSize;
 
 public:
 	//debug and statistics info.
diff --git a/indra/llcommon/llthread.h b/indra/llcommon/llthread.h
index c732e3bc77..b631b96252 100644
--- a/indra/llcommon/llthread.h
+++ b/indra/llcommon/llthread.h
@@ -195,7 +195,8 @@ public:
 	}
 	~LLMutex()
 	{
-		llassert(!isLocked()); // better not be locked!
+		//this assertion erroneously triggers whenever an LLCondition is destroyed
+		//llassert(!isLocked()); // better not be locked!
 		apr_thread_mutex_destroy(mAPRMutexp);
 		mAPRMutexp = NULL;
 	}
diff --git a/indra/llcommon/llversionviewer.h b/indra/llcommon/llversionviewer.h
index ef55cfec89..e4ad7f4f54 100755..100644
--- a/indra/llcommon/llversionviewer.h
+++ b/indra/llcommon/llversionviewer.h
@@ -28,8 +28,8 @@
 #define LL_LLVERSIONVIEWER_H
 
 const S32 LL_VERSION_MAJOR = 3;
-const S32 LL_VERSION_MINOR = 0;
-const S32 LL_VERSION_PATCH = 5;
+const S32 LL_VERSION_MINOR = 1;
+const S32 LL_VERSION_PATCH = 1;
 const S32 LL_VERSION_BUILD = 0;
 
 const char * const LL_CHANNEL = "Second Life Developer";