Merge branch 'master' of git://github.com/Shyotl/SingularityViewer

Conflicts:
	indra/newview/llpanelmaininventory.cpp
	indra/newview/llpanelmaininventory.h
	indra/newview/llvoavatar.cpp

indra/llaudio/llstreamingaudio_fmodex.cpp

@@ -74,7 +74,9 @@ LLStreamingAudio_FMODEX::LLStreamingAudio_FMODEX(FMOD::System *system) :
 {
 	// Number of milliseconds of audio to buffer for the audio card.
 	// Must be larger than the usual Second Life frame stutter time.
-	mSystem->setStreamBufferSize(200, FMOD_TIMEUNIT_MS);
+	const U32 buffer_seconds = 5;		//sec
+	const U32 estimated_bitrate = 128;	//kbit/sec
+	mSystem->setStreamBufferSize(estimated_bitrate * buffer_seconds * 128/*bytes/kbit*/, FMOD_TIMEUNIT_RAWBYTES);
 
 	// Here's where we set the size of the network buffer and some buffering 
 	// parameters.  In this case we want a network buffer of 16k, we want it 

indra/llcommon/CMakeLists.txt

@@ -17,7 +17,9 @@ include_directories(
 set(llcommon_SOURCE_FILES
 	aiframetimer.cpp
 	imageids.cpp
-	indra_constants.cpp
+    indra_constants.cpp
+    llallocator.cpp
+    llallocator_heap_profile.cpp
     llapp.cpp
     llapr.cpp
     llaprpool.cpp
@@ -52,6 +54,7 @@ set(llcommon_SOURCE_FILES
     llmd5.cpp
     llmemory.cpp
     llmemorystream.cpp
+    llmemtype.cpp
     llmetrics.cpp
     llmortician.cpp
     lloptioninterface.cpp
@@ -101,6 +104,8 @@ set(llcommon_HEADER_FILES
     linden_common.h
     linked_lists.h
     llaccountingcost.h
+    llallocator.h
+    llallocator_heap_profile.h
     llagentconstants.h
     llavatarname.h
     llapp.h

indra/llcommon/llallocator.cpp

@@ -0,0 +1,134 @@
+/** 
+ * @file llallocator.cpp
+ * @brief Implementation of the LLAllocator class.
+ *
+ * $LicenseInfo:firstyear=2009&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 "llallocator.h"
+
+#if LL_USE_TCMALLOC
+
+#include "google/heap-profiler.h"
+#include "google/commandlineflags_public.h"
+
+DECLARE_bool(heap_profile_use_stack_trace);
+//DECLARE_double(tcmalloc_release_rate);
+
+// static
+void LLAllocator::pushMemType(S32 type)
+{
+    if(isProfiling())
+    {
+    	PushMemType(type);
+    }
+}
+
+// static
+S32 LLAllocator::popMemType()
+{
+    if (isProfiling())
+    {
+    	return PopMemType();
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+void LLAllocator::setProfilingEnabled(bool should_enable)
+{
+    // NULL disables dumping to disk
+    static char const * const PREFIX = NULL;
+    if(should_enable)
+    {
+		HeapProfilerSetUseStackTrace(false);
+        HeapProfilerStart(PREFIX);
+    }
+    else
+    {
+        HeapProfilerStop();
+    }
+}
+
+// static
+bool LLAllocator::isProfiling()
+{
+    return IsHeapProfilerRunning();
+}
+
+std::string LLAllocator::getRawProfile()
+{
+    // *TODO - fix google-perftools to accept an buffer to avoid this
+    // malloc-copy-free cycle.
+    char * buffer = GetHeapProfile();
+    std::string ret = buffer;
+    free(buffer);
+    return ret;
+}
+
+#else // LL_USE_TCMALLOC
+
+//
+// stub implementations for when tcmalloc is disabled
+//
+
+// static
+void LLAllocator::pushMemType(S32 type)
+{
+}
+
+// static
+S32 LLAllocator::popMemType()
+{
+    return -1;
+}
+
+void LLAllocator::setProfilingEnabled(bool should_enable)
+{
+}
+
+// static
+bool LLAllocator::isProfiling()
+{
+    return false;
+}
+
+std::string LLAllocator::getRawProfile()
+{
+    return std::string();
+}
+
+#endif // LL_USE_TCMALLOC
+
+LLAllocatorHeapProfile const & LLAllocator::getProfile()
+{
+    mProf.mLines.clear();
+
+    // *TODO - avoid making all these extra copies of things...
+    std::string prof_text = getRawProfile();
+    //std::cout << prof_text << std::endl;
+    mProf.parse(prof_text);
+    return mProf;
+}

indra/llcommon/llallocator.h

@@ -0,0 +1,57 @@
+/** 
+ * @file llallocator.h
+ * @brief Declaration of the LLAllocator class.
+ *
+ * $LicenseInfo:firstyear=2009&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_LLALLOCATOR_H
+#define LL_LLALLOCATOR_H
+
+#include <string>
+
+#include "llmemtype.h"
+#include "llallocator_heap_profile.h"
+
+class LL_COMMON_API LLAllocator {
+    friend class LLMemoryView;
+    friend class LLMemType;
+
+private:
+	static void pushMemType(S32 type);
+	static S32 popMemType();
+
+public:
+    void setProfilingEnabled(bool should_enable);
+
+    static bool isProfiling();
+
+    LLAllocatorHeapProfile const & getProfile();
+
+private:
+    std::string getRawProfile();
+
+private:
+    LLAllocatorHeapProfile mProf;
+};
+
+#endif // LL_LLALLOCATOR_H

indra/llcommon/llallocator_heap_profile.cpp

@@ -0,0 +1,147 @@
+/** 
+ * @file llallocator_heap_profile.cpp
+ * @brief Implementation of the parser for tcmalloc heap profile data.
+ * @author Brad Kittenbrink
+ *
+ * $LicenseInfo:firstyear=2009&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 "llallocator_heap_profile.h"
+
+#if LL_MSVC
+// disable warning about boost::lexical_cast returning uninitialized data
+// when it fails to parse the string
+#pragma warning (disable:4701)
+#pragma warning (disable:4702)
+#endif
+
+#include <boost/algorithm/string/split.hpp>
+#include <boost/bind.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/range/iterator_range.hpp>
+
+static const std::string HEAP_PROFILE_MAGIC_STR = "heap profile:";
+
+static bool is_separator(char c)
+{
+    return isspace(c) || c == '[' || c == ']' || c == ':';
+}
+
+void LLAllocatorHeapProfile::parse(std::string const & prof_text)
+{
+    // a typedef for handling a token in the string buffer
+    // it's a begin/end pair of string::const_iterators
+    typedef boost::iterator_range<std::string::const_iterator> range_t;
+
+    mLines.clear();
+
+    if(prof_text.compare(0, HEAP_PROFILE_MAGIC_STR.length(), HEAP_PROFILE_MAGIC_STR) != 0)
+    {
+        // *TODO - determine if there should be some better error state than
+        // mLines being empty. -brad
+        llwarns << "invalid heap profile data passed into parser." << llendl;
+        return;
+    }
+
+    std::vector< range_t > prof_lines;
+
+    std::string::const_iterator prof_begin = prof_text.begin() + HEAP_PROFILE_MAGIC_STR.length();
+
+	range_t prof_range(prof_begin, prof_text.end());
+    boost::algorithm::split(prof_lines,
+        prof_range,
+        boost::bind(std::equal_to<llwchar>(), '\n', _1));
+
+    std::vector< range_t >::const_iterator i;
+    for(i = prof_lines.begin(); i != prof_lines.end() && !i->empty(); ++i)
+    {
+        range_t const & line_text = *i;
+
+        std::vector<range_t> line_elems;
+
+        boost::algorithm::split(line_elems,
+            line_text,
+            is_separator);
+
+        std::vector< range_t >::iterator j;
+        j = line_elems.begin();
+
+        while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
+        llassert_always(j != line_elems.end());
+        U32 live_count = boost::lexical_cast<U32>(*j);
+        ++j;
+
+        while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
+        llassert_always(j != line_elems.end());
+        U64 live_size = boost::lexical_cast<U64>(*j);
+        ++j;
+
+        while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
+        llassert_always(j != line_elems.end());
+        U32 tot_count = boost::lexical_cast<U32>(*j);
+        ++j;
+
+        while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
+        llassert_always(j != line_elems.end());
+        U64 tot_size = boost::lexical_cast<U64>(*j);
+        ++j;
+
+        while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
+	llassert(j != line_elems.end());
+        if (j != line_elems.end())
+	{
+		++j; // skip the '@'
+
+		mLines.push_back(line(live_count, live_size, tot_count, tot_size));
+		line & current_line = mLines.back();
+		
+		for(; j != line_elems.end(); ++j)
+		{
+			if(!j->empty())
+			{
+				U32 marker = boost::lexical_cast<U32>(*j);
+				current_line.mTrace.push_back(marker);
+			}
+		}
+	}
+    }
+    // *TODO - parse MAPPED_LIBRARIES section here if we're ever interested in it
+}
+
+void LLAllocatorHeapProfile::dump(std::ostream & out) const
+{
+    lines_t::const_iterator i;
+    for(i = mLines.begin(); i != mLines.end(); ++i)
+    {
+        out << i->mLiveCount << ": " << i->mLiveSize << '[' << i->mTotalCount << ": " << i->mTotalSize << "] @";
+
+        stack_trace::const_iterator j;
+        for(j = i->mTrace.begin(); j != i->mTrace.end(); ++j)
+        {
+            out << ' ' << *j;
+        }
+        out << '\n';
+    }
+    out.flush();
+}
+

indra/llcommon/llallocator_heap_profile.h

@@ -0,0 +1,71 @@
+/** 
+ * @file llallocator_heap_profile.h
+ * @brief Declaration of the parser for tcmalloc heap profile data.
+ * @author Brad Kittenbrink
+ *
+ * $LicenseInfo:firstyear=2009&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_LLALLOCATOR_HEAP_PROFILE_H
+#define LL_LLALLOCATOR_HEAP_PROFILE_H
+
+#include "stdtypes.h"
+
+#include <map>
+#include <vector>
+
+class LLAllocatorHeapProfile
+{
+public:
+    typedef int stack_marker;
+
+    typedef std::vector<stack_marker> stack_trace;
+
+    struct line {
+        line(U32 live_count, U64 live_size, U32 tot_count, U64 tot_size) :
+            mLiveSize(live_size),
+            mTotalSize(tot_size),
+            mLiveCount(live_count),
+            mTotalCount(tot_count)
+        {
+        }
+        U64 mLiveSize, mTotalSize;
+        U32 mLiveCount, mTotalCount;
+        stack_trace mTrace;
+    };
+
+    typedef std::vector<line> lines_t;
+
+    LLAllocatorHeapProfile()
+    {
+    }
+
+	void parse(std::string const & prof_text);
+
+    void dump(std::ostream & out) const;
+
+public:
+    lines_t mLines;
+};
+
+
+#endif // LL_LLALLOCATOR_HEAP_PROFILE_H

indra/llcommon/llfasttimer_class.h

@@ -248,6 +248,7 @@ public:
 
 	struct CurTimerData
 	{
+		CurTimerData() : mCurTimer(NULL),mFrameState(NULL),mChildTime(0) {}
 		LLFastTimer*	mCurTimer;
 		FrameState*		mFrameState;
 		U32				mChildTime;

indra/llcommon/llmemory.cpp

@@ -32,9 +32,13 @@
 
 #include "linden_common.h"
 
+
+//#if MEM_TRACK_MEM
+#include "llthread.h"
+//#endif
+
 #if defined(LL_WINDOWS)
-#define _WINSOCKAPI_
+//# include <windows.h>
-# include <windows.h>
 # include <psapi.h>
 #elif defined(LL_DARWIN)
 # include <sys/types.h>
@@ -45,10 +49,9 @@
 #endif
 
 #include "llmemory.h"
-#include "llmemtype.h"
-#include "llsys.h"
-#include "llthread.h"
 
+#include "llsys.h"
+#include "llframetimer.h"
 //----------------------------------------------------------------------------
 
 //static
@@ -162,6 +165,7 @@ void LLMemory::logMemoryInfo(BOOL update)
 	if(update)
 	{
 		updateMemoryInfo() ;
+		LLPrivateMemoryPoolManager::getInstance()->updateStatistics() ;
 	}
 
 	llinfos << "Current allocated physical memory(KB): " << sAllocatedMemInKB << llendl ;
@@ -242,161 +246,6 @@ U32 LLMemory::getAllocatedMemKB()
 	return sAllocatedMemInKB ;
 }
 
-//----------------------------------------------------------------------------
-
-//static
-#if MEM_TRACK_TYPE
-S32 LLMemType::sCurDepth = 0;
-S32 LLMemType::sCurType = LLMemType::MTYPE_INIT;
-S32 LLMemType::sType[LLMemType::MTYPE_MAX_DEPTH];
-S32 LLMemType::sMemCount[LLMemType::MTYPE_NUM_TYPES] = { 0 };
-S32 LLMemType::sMaxMemCount[LLMemType::MTYPE_NUM_TYPES] = { 0 };
-S32 LLMemType::sNewCount[LLMemType::MTYPE_NUM_TYPES] = { 0 };
-S32 LLMemType::sOverheadMem = 0;
-
-const char* LLMemType::sTypeDesc[LLMemType::MTYPE_NUM_TYPES] =
-{
-	"INIT",
-	"STARTUP",
-	"MAIN",
-	
-	"IMAGEBASE",
-	"IMAGERAW",
-	"IMAGEFORMATTED",
-	
-	"APPFMTIMAGE",
-	"APPRAWIMAGE",
-	"APPAUXRAWIMAGE",
-	
-	"DRAWABLE",
-	"OBJECT",
-	"PIPELINE",
-	"AVATAR",
-	"PARTICLES",
-	"REGIONS",
-	"INVENTORY",
-	"ANIMATION",
-	"NETWORK",
-	"PHYSICS",
-	"INTERESTLIST",
-	
-	"SCRIPT",
-	"SCRIPT_RUN",
-	"SCRIPT_BYTECODE",
-	
-	"IO_PUMP",
-	"IO_TCP",
-	"IO_BUFFER",
-	"IO_HTTP_SERVER"
-	"IO_SD_SERVER",
-	"IO_SD_CLIENT",
-	"IO_URL_REQUEST",
-
-	"TEMP1",
-	"TEMP2",
-	"TEMP3",
-	"TEMP4",
-	"TEMP5",
-	"TEMP6",
-	"TEMP7",
-	"TEMP8",
-	"TEMP9"
-};
-
-#endif
-S32 LLMemType::sTotalMem = 0;
-S32 LLMemType::sMaxTotalMem = 0;
-
-//static
-void LLMemType::printMem()
-{
-	S32 misc_mem = sTotalMem;
-#if MEM_TRACK_TYPE
-	for (S32 i=0; i<MTYPE_NUM_TYPES; i++)
-	{
-		if (sMemCount[i])
-		{
-			llinfos << llformat("MEM: % 20s %03d MB (%03d MB) in %06d News",sTypeDesc[i],sMemCount[i]>>20,sMaxMemCount[i]>>20, sNewCount[i]) << llendl;
-		}
-		misc_mem -= sMemCount[i];
-	}
-#endif
-	llinfos << llformat("MEM: % 20s %03d MB","MISC",misc_mem>>20) << llendl;
-	llinfos << llformat("MEM: % 20s %03d MB (Max=%d MB)","TOTAL",sTotalMem>>20,sMaxTotalMem>>20) << llendl;
-}
-
-#if MEM_TRACK_MEM
-
-void* ll_allocate (size_t size)
-{
-	if (size == 0)
-	{
-		llwarns << "Null allocation" << llendl;
-	}
-	
-	size = (size+3)&~3;
-	S32 alloc_size = size + 4;
-#if MEM_TRACK_TYPE
-	alloc_size += 4;
-#endif
-	char* p = (char*)malloc(alloc_size);
-	if (p == NULL)
-	{
-		LLMemory::freeReserve();
-		llerrs << "Out of memory Error" << llendl;
-	}
-	LLMemType::sTotalMem += size;
-	LLMemType::sMaxTotalMem = llmax(LLMemType::sTotalMem, LLMemType::sMaxTotalMem);
-	LLMemType::sOverheadMem += 4;
-	*(size_t*)p = size;
-	p += 4;
-#if MEM_TRACK_TYPE
-	if (LLMemType::sCurType < 0 || LLMemType::sCurType >= LLMemType::MTYPE_NUM_TYPES)
-	{
-		llerrs << "Memory Type Error: new" << llendl;
-	}
-	LLMemType::sOverheadMem += 4;
-	*(S32*)p = LLMemType::sCurType;
-	p += 4;
-	LLMemType::sMemCount[LLMemType::sCurType] += size;
-	if (LLMemType::sMemCount[LLMemType::sCurType] > LLMemType::sMaxMemCount[LLMemType::sCurType])
-	{
-		LLMemType::sMaxMemCount[LLMemType::sCurType] = LLMemType::sMemCount[LLMemType::sCurType];
-	}
-	LLMemType::sNewCount[LLMemType::sCurType]++;
-#endif
-	return (void*)p;
-}
-
-void ll_release (void *pin)
-{
-	if (!pin)
-	{
-		return;
-	}
-	char* p = (char*)pin;
-#if MEM_TRACK_TYPE
-	p -= 4;
-	S32 type = *(S32*)p;
-	if (type < 0 || type >= LLMemType::MTYPE_NUM_TYPES)
-	{
-		llerrs << "Memory Type Error: delete" << llendl;
-	}
-#endif
-	p -= 4;
-	S32 size = *(size_t*)p;
-	LLMemType::sOverheadMem -= 4;
-#if MEM_TRACK_TYPE
-	LLMemType::sMemCount[type] -= size;
-	LLMemType::sOverheadMem -= 4;
-	LLMemType::sNewCount[type]--;
-#endif
-	LLMemType::sTotalMem -= size;
-	free(p);
-}
-
-#else
-
 void* ll_allocate (size_t size)
 {
 	if (size == 0)
@@ -412,38 +261,6 @@ void* ll_allocate (size_t size)
 	return p;
 }
 
-void ll_release (void *p)
-{
-	free(p);
-}
-
-#endif
-
-#if MEM_TRACK_MEM
-
-void* operator new (size_t size)
-{
-	return ll_allocate(size);
-}
-
-void* operator new[] (size_t size)
-{
-	return ll_allocate(size);
-}
-
-void operator delete (void *p)
-{
-	ll_release(p);
-}
-
-void operator delete[] (void *p)
-{
-	ll_release(p);
-}
-
-#endif
-
-
 //----------------------------------------------------------------------------
 
 #if defined(LL_WINDOWS)
@@ -613,6 +430,141 @@ U32 LLMemory::getWorkingSetSize()
 
 #endif
 
+//--------------------------------------------------------------------------------------------------
+#if MEM_TRACK_MEM
+#include "llframetimer.h"
+
+//static 
+LLMemTracker* LLMemTracker::sInstance = NULL ;
+
+LLMemTracker::LLMemTracker()
+{
+	mLastAllocatedMem = LLMemory::getWorkingSetSize() ;
+	mCapacity = 128 ;	
+	mCurIndex = 0 ;
+	mCounter = 0 ;
+	mDrawnIndex = 0 ;
+	mPaused = FALSE ;
+
+	mMutexp = new LLMutex() ;
+	mStringBuffer = new char*[128] ;
+	mStringBuffer[0] = new char[mCapacity * 128] ;
+	for(S32 i = 1 ; i < mCapacity ; i++)
+	{
+		mStringBuffer[i] = mStringBuffer[i-1] + 128 ;
+	}
+}
+
+LLMemTracker::~LLMemTracker()
+{
+	delete[] mStringBuffer[0] ;
+	delete[] mStringBuffer;
+	delete mMutexp ;
+}
+
+//static 
+LLMemTracker* LLMemTracker::getInstance()
+{
+	if(!sInstance)
+	{
+		sInstance = new LLMemTracker() ;
+	}
+	return sInstance ;
+}
+
+//static 
+void LLMemTracker::release() 
+{
+	if(sInstance)
+	{
+		delete sInstance ;
+		sInstance = NULL ;
+	}
+}
+
+//static
+void LLMemTracker::track(const char* function, const int line)
+{
+	static const S32 MIN_ALLOCATION = 0 ; //1KB
+
+	if(mPaused)
+	{
+		return ;
+	}
+
+	U32 allocated_mem = LLMemory::getWorkingSetSize() ;
+
+	LLMutexLock lock(mMutexp) ;
+
+	S32 delta_mem = allocated_mem - mLastAllocatedMem ;
+	mLastAllocatedMem = allocated_mem ;
+
+	if(delta_mem <= 0)
+	{
+		return ; //occupied memory does not grow
+	}
+
+	if(delta_mem < MIN_ALLOCATION)
+	{
+		return ;
+	}
+		
+	char* buffer = mStringBuffer[mCurIndex++] ;
+	F32 time = (F32)LLFrameTimer::getElapsedSeconds() ;
+	S32 hours = (S32)(time / (60*60));
+	S32 mins = (S32)((time - hours*(60*60)) / 60);
+	S32 secs = (S32)((time - hours*(60*60) - mins*60));
+	strcpy(buffer, function) ;
+	sprintf(buffer + strlen(function), " line: %d DeltaMem: %d (bytes) Time: %d:%02d:%02d", line, delta_mem, hours,mins,secs) ;
+
+	if(mCounter < mCapacity)
+	{
+		mCounter++ ;
+	}
+	if(mCurIndex >= mCapacity)
+	{
+		mCurIndex = 0 ;		
+	}
+}
+
+
+//static 
+void LLMemTracker::preDraw(BOOL pause) 
+{
+	mMutexp->lock() ;
+
+	mPaused = pause ;
+	mDrawnIndex = mCurIndex - 1;
+	mNumOfDrawn = 0 ;
+}
+	
+//static 
+void LLMemTracker::postDraw() 
+{
+	mMutexp->unlock() ;
+}
+
+//static 
+const char* LLMemTracker::getNextLine() 
+{
+	if(mNumOfDrawn >= mCounter)
+	{
+		return NULL ;
+	}
+	mNumOfDrawn++;
+
+	if(mDrawnIndex < 0)
+	{
+		mDrawnIndex = mCapacity - 1 ;
+	}
+
+	return mStringBuffer[mDrawnIndex--] ;
+}
+
+#endif //MEM_TRACK_MEM
+//--------------------------------------------------------------------------------------------------
+
+
 //--------------------------------------------------------------------------------------------------
 //--------------------------------------------------------------------------------------------------
 //minimum slot size and minimal slot size interval

indra/llcommon/llmemory.h

@@ -40,6 +40,7 @@
 #endif
 
 #include "llerror.h"
+#include "llmemtype.h"
 #if LL_DEBUG
 inline void* ll_aligned_malloc( size_t size, int align )
 {

indra/llcommon/llmemtype.cpp

@@ -0,0 +1,232 @@
+/** 
+ * @file llmemtype.cpp
+ * @brief Simple memory allocation/deallocation tracking stuff here
+ *
+ * $LicenseInfo:firstyear=2002&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 "llmemtype.h"
+#include "llallocator.h"
+
+std::vector<char const *> LLMemType::DeclareMemType::mNameList;
+
+LLMemType::DeclareMemType LLMemType::MTYPE_INIT("Init");
+LLMemType::DeclareMemType LLMemType::MTYPE_STARTUP("Startup");
+LLMemType::DeclareMemType LLMemType::MTYPE_MAIN("Main");
+LLMemType::DeclareMemType LLMemType::MTYPE_FRAME("Frame");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_GATHER_INPUT("GatherInput");
+LLMemType::DeclareMemType LLMemType::MTYPE_JOY_KEY("JoyKey");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_IDLE("Idle");
+LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_PUMP("IdlePump");
+LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_NETWORK("IdleNetwork");
+LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_UPDATE_REGIONS("IdleUpdateRegions");
+LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_UPDATE_VIEWER_REGION("IdleUpdateViewerRegion");
+LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_UPDATE_SURFACE("IdleUpdateSurface");
+LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_UPDATE_PARCEL_OVERLAY("IdleUpdateParcelOverlay");
+LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_AUDIO("IdleAudio");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_CACHE_PROCESS_PENDING("CacheProcessPending");
+LLMemType::DeclareMemType LLMemType::MTYPE_CACHE_PROCESS_PENDING_ASKS("CacheProcessPendingAsks");
+LLMemType::DeclareMemType LLMemType::MTYPE_CACHE_PROCESS_PENDING_REPLIES("CacheProcessPendingReplies");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_MESSAGE_CHECK_ALL("MessageCheckAll");
+LLMemType::DeclareMemType LLMemType::MTYPE_MESSAGE_PROCESS_ACKS("MessageProcessAcks");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_RENDER("Render");
+LLMemType::DeclareMemType LLMemType::MTYPE_SLEEP("Sleep");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_NETWORK("Network");
+LLMemType::DeclareMemType LLMemType::MTYPE_PHYSICS("Physics");
+LLMemType::DeclareMemType LLMemType::MTYPE_INTERESTLIST("InterestList");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_IMAGEBASE("ImageBase");
+LLMemType::DeclareMemType LLMemType::MTYPE_IMAGERAW("ImageRaw");
+LLMemType::DeclareMemType LLMemType::MTYPE_IMAGEFORMATTED("ImageFormatted");
+		
+LLMemType::DeclareMemType LLMemType::MTYPE_APPFMTIMAGE("AppFmtImage");
+LLMemType::DeclareMemType LLMemType::MTYPE_APPRAWIMAGE("AppRawImage");
+LLMemType::DeclareMemType LLMemType::MTYPE_APPAUXRAWIMAGE("AppAuxRawImage");
+		
+LLMemType::DeclareMemType LLMemType::MTYPE_DRAWABLE("Drawable");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_OBJECT("Object");
+LLMemType::DeclareMemType LLMemType::MTYPE_OBJECT_PROCESS_UPDATE("ObjectProcessUpdate");
+LLMemType::DeclareMemType LLMemType::MTYPE_OBJECT_PROCESS_UPDATE_CORE("ObjectProcessUpdateCore");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY("Display");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_UPDATE("DisplayUpdate");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_UPDATE_CAMERA("DisplayUpdateCam");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_UPDATE_GEOM("DisplayUpdateGeom");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_SWAP("DisplaySwap");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_UPDATE_HUD("DisplayUpdateHud");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_GEN_REFLECTION("DisplayGenRefl");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_IMAGE_UPDATE("DisplayImageUpdate");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_STATE_SORT("DisplayStateSort");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_SKY("DisplaySky");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_RENDER_GEOM("DisplayRenderGeom");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_RENDER_FLUSH("DisplayRenderFlush");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_RENDER_UI("DisplayRenderUI");
+LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_RENDER_ATTACHMENTS("DisplayRenderAttach");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_DATA("VertexData");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_CONSTRUCTOR("VertexConstr");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_DESTRUCTOR("VertexDestr");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_CREATE_VERTICES("VertexCreateVerts");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_CREATE_INDICES("VertexCreateIndices");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_DESTROY_BUFFER("VertexDestroyBuff");	
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_DESTROY_INDICES("VertexDestroyIndices");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_UPDATE_VERTS("VertexUpdateVerts");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_UPDATE_INDICES("VertexUpdateIndices");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_ALLOCATE_BUFFER("VertexAllocateBuffer");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_RESIZE_BUFFER("VertexResizeBuffer");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_MAP_BUFFER("VertexMapBuffer");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_MAP_BUFFER_VERTICES("VertexMapBufferVerts");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_MAP_BUFFER_INDICES("VertexMapBufferIndices");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_UNMAP_BUFFER("VertexUnmapBuffer");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_SET_STRIDE("VertexSetStride");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_SET_BUFFER("VertexSetBuffer");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_SETUP_VERTEX_BUFFER("VertexSetupVertBuff");
+LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_CLEANUP_CLASS("VertexCleanupClass");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_SPACE_PARTITION("SpacePartition");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE("Pipeline");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_INIT("PipelineInit");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_CREATE_BUFFERS("PipelineCreateBuffs");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RESTORE_GL("PipelineRestroGL");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_UNLOAD_SHADERS("PipelineUnloadShaders");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_LIGHTING_DETAIL("PipelineLightingDetail");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_GET_POOL_TYPE("PipelineGetPoolType");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_ADD_POOL("PipelineAddPool");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_ALLOCATE_DRAWABLE("PipelineAllocDrawable");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_ADD_OBJECT("PipelineAddObj");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_CREATE_OBJECTS("PipelineCreateObjs");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_UPDATE_MOVE("PipelineUpdateMove");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_UPDATE_GEOM("PipelineUpdateGeom");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_MARK_VISIBLE("PipelineMarkVisible");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_MARK_MOVED("PipelineMarkMoved");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_MARK_SHIFT("PipelineMarkShift");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_SHIFT_OBJECTS("PipelineShiftObjs");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_MARK_TEXTURED("PipelineMarkTextured");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_MARK_REBUILD("PipelineMarkRebuild");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_UPDATE_CULL("PipelineUpdateCull");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_STATE_SORT("PipelineStateSort");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_POST_SORT("PipelinePostSort");
+		
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_HUD_ELS("PipelineHudEls");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_HL("PipelineRenderHL");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_GEOM("PipelineRenderGeom");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_GEOM_DEFFERRED("PipelineRenderGeomDef");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_GEOM_POST_DEF("PipelineRenderGeomPostDef");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_GEOM_SHADOW("PipelineRenderGeomShadow");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_SELECT("PipelineRenderSelect");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_REBUILD_POOLS("PipelineRebuildPools");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_QUICK_LOOKUP("PipelineQuickLookup");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_OBJECTS("PipelineRenderObjs");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_GENERATE_IMPOSTOR("PipelineGenImpostors");
+LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_BLOOM("PipelineRenderBloom");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_UPKEEP_POOLS("UpkeepPools");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_AVATAR("Avatar");
+LLMemType::DeclareMemType LLMemType::MTYPE_AVATAR_MESH("AvatarMesh");
+LLMemType::DeclareMemType LLMemType::MTYPE_PARTICLES("Particles");
+LLMemType::DeclareMemType LLMemType::MTYPE_REGIONS("Regions");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY("Inventory");
+LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_DRAW("InventoryDraw");
+LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_BUILD_NEW_VIEWS("InventoryBuildNewViews");
+LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_DO_FOLDER("InventoryDoFolder");
+LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_POST_BUILD("InventoryPostBuild");
+LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_FROM_XML("InventoryFromXML");
+LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_CREATE_NEW_ITEM("InventoryCreateNewItem");
+LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_VIEW_INIT("InventoryViewInit");
+LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_VIEW_SHOW("InventoryViewShow");
+LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_VIEW_TOGGLE("InventoryViewToggle");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_ANIMATION("Animation");
+LLMemType::DeclareMemType LLMemType::MTYPE_VOLUME("Volume");
+LLMemType::DeclareMemType LLMemType::MTYPE_PRIMITIVE("Primitive");
+		
+LLMemType::DeclareMemType LLMemType::MTYPE_SCRIPT("Script");
+LLMemType::DeclareMemType LLMemType::MTYPE_SCRIPT_RUN("ScriptRun");
+LLMemType::DeclareMemType LLMemType::MTYPE_SCRIPT_BYTECODE("ScriptByteCode");
+		
+LLMemType::DeclareMemType LLMemType::MTYPE_IO_PUMP("IoPump");
+LLMemType::DeclareMemType LLMemType::MTYPE_IO_TCP("IoTCP");
+LLMemType::DeclareMemType LLMemType::MTYPE_IO_BUFFER("IoBuffer");
+LLMemType::DeclareMemType LLMemType::MTYPE_IO_HTTP_SERVER("IoHttpServer");
+LLMemType::DeclareMemType LLMemType::MTYPE_IO_SD_SERVER("IoSDServer");
+LLMemType::DeclareMemType LLMemType::MTYPE_IO_SD_CLIENT("IoSDClient");
+LLMemType::DeclareMemType LLMemType::MTYPE_IO_URL_REQUEST("IOUrlRequest");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_DIRECTX_INIT("DirectXInit");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_TEMP1("Temp1");
+LLMemType::DeclareMemType LLMemType::MTYPE_TEMP2("Temp2");
+LLMemType::DeclareMemType LLMemType::MTYPE_TEMP3("Temp3");
+LLMemType::DeclareMemType LLMemType::MTYPE_TEMP4("Temp4");
+LLMemType::DeclareMemType LLMemType::MTYPE_TEMP5("Temp5");
+LLMemType::DeclareMemType LLMemType::MTYPE_TEMP6("Temp6");
+LLMemType::DeclareMemType LLMemType::MTYPE_TEMP7("Temp7");
+LLMemType::DeclareMemType LLMemType::MTYPE_TEMP8("Temp8");
+LLMemType::DeclareMemType LLMemType::MTYPE_TEMP9("Temp9");
+
+LLMemType::DeclareMemType LLMemType::MTYPE_OTHER("Other");
+
+
+LLMemType::DeclareMemType::DeclareMemType(char const * st)
+{
+	mID = (S32)mNameList.size();
+	mName = st;
+
+	mNameList.push_back(mName);
+}
+
+LLMemType::DeclareMemType::~DeclareMemType()
+{
+}
+
+LLMemType::LLMemType(LLMemType::DeclareMemType& dt)
+{
+	mTypeIndex = dt.mID;
+	LLAllocator::pushMemType(dt.mID);
+}
+
+LLMemType::~LLMemType()
+{
+	LLAllocator::popMemType();
+}
+
+char const * LLMemType::getNameFromID(S32 id)
+{
+	if (id < 0 || id >= (S32)DeclareMemType::mNameList.size())
+	{
+		return "INVALID";
+	}
+
+	return DeclareMemType::mNameList[id];
+}
+
+//--------------------------------------------------------------------------------------------------

indra/llcommon/llmemtype.h

@@ -36,128 +36,210 @@
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-class LLMemType;
-
-extern void* ll_allocate (size_t size);
-extern void ll_release (void *p);
-
-#define MEM_TRACK_MEM 0
-#define MEM_TRACK_TYPE (1 && MEM_TRACK_MEM)
-
-#if MEM_TRACK_TYPE
-#define MEM_DUMP_DATA 1
-#define MEM_TYPE_NEW(T) \
-static void* operator new(size_t s) { LLMemType mt(T); return ll_allocate(s); } \
-static void  operator delete(void* p) { ll_release(p); }
-
-#else
-#define MEM_TYPE_NEW(T)
-#endif // MEM_TRACK_TYPE
-
-
 //----------------------------------------------------------------------------
 
+#include "linden_common.h"
+//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// WARNING: Never commit with MEM_TRACK_MEM == 1
+//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+#define MEM_TRACK_MEM (0 && LL_WINDOWS)
+
+#include <vector>
+
+#define MEM_TYPE_NEW(T)
+
 class LL_COMMON_API LLMemType
 {
 public:
-	// Also update sTypeDesc in llmemory.cpp
+
-	enum EMemType
+	// class we'll initialize all instances of as
+	// static members of MemType.  Then use
+	// to construct any new mem type.
+	class LL_COMMON_API DeclareMemType
 	{
-		MTYPE_INIT,
+	public:
-		MTYPE_STARTUP,
+		DeclareMemType(char const * st);
-		MTYPE_MAIN,
+		~DeclareMemType();
-
+	
-		MTYPE_IMAGEBASE,
+		S32 mID;
-		MTYPE_IMAGERAW,
+		char const * mName;
-		MTYPE_IMAGEFORMATTED,
 		
-		MTYPE_APPFMTIMAGE,
+		// array so we can map an index ID to Name
-		MTYPE_APPRAWIMAGE,
+		static std::vector<char const *> mNameList;
-		MTYPE_APPAUXRAWIMAGE,
-		
-		MTYPE_DRAWABLE,
-		MTYPE_OBJECT,
-		MTYPE_VERTEX_DATA,
-		MTYPE_SPACE_PARTITION,
-		MTYPE_PIPELINE,
-		MTYPE_AVATAR,
-		MTYPE_AVATAR_MESH,
-		MTYPE_PARTICLES,
-		MTYPE_REGIONS,
-		MTYPE_INVENTORY,
-		MTYPE_ANIMATION,
-		MTYPE_VOLUME,
-		MTYPE_PRIMITIVE,
-
-		MTYPE_NETWORK,
-		MTYPE_PHYSICS,
-		MTYPE_INTERESTLIST,
-		
-		MTYPE_SCRIPT,
-		MTYPE_SCRIPT_RUN,
-		MTYPE_SCRIPT_BYTECODE,
-		
-		MTYPE_IO_PUMP,
-		MTYPE_IO_TCP,
-		MTYPE_IO_BUFFER,
-		MTYPE_IO_HTTP_SERVER,
-		MTYPE_IO_SD_SERVER,
-		MTYPE_IO_SD_CLIENT,
-		MTYPE_IO_URL_REQUEST,
-
-		MTYPE_TEMP1,
-		MTYPE_TEMP2,
-		MTYPE_TEMP3,
-		MTYPE_TEMP4,
-		MTYPE_TEMP5,
-		MTYPE_TEMP6,
-		MTYPE_TEMP7,
-		MTYPE_TEMP8,
-		MTYPE_TEMP9,
-
-		MTYPE_OTHER, // Special, used by display code
-		
-		MTYPE_NUM_TYPES
 	};
-	enum { MTYPE_MAX_DEPTH = 64 };
-	
-public:
-	LLMemType(EMemType type)
-	{
-#if MEM_TRACK_TYPE
-		if (type < 0 || type >= MTYPE_NUM_TYPES)
-			llerrs << "LLMemType error" << llendl;
-		if (sCurDepth < 0 || sCurDepth >= MTYPE_MAX_DEPTH)
-			llerrs << "LLMemType error" << llendl;
-		sType[sCurDepth] = sCurType;
-		sCurDepth++;
-		sCurType = type;
-#endif
-	}
-	~LLMemType()
-	{
-#if MEM_TRACK_TYPE
-		sCurDepth--;
-		sCurType = sType[sCurDepth];
-#endif
-	}
 
-	static void reset();
+	LLMemType(DeclareMemType& dt);
-	static void printMem();
+	~LLMemType();
+
+	static char const * getNameFromID(S32 id);
+
+	static DeclareMemType MTYPE_INIT;
+	static DeclareMemType MTYPE_STARTUP;
+	static DeclareMemType MTYPE_MAIN;
+	static DeclareMemType MTYPE_FRAME;
+
+	static DeclareMemType MTYPE_GATHER_INPUT;
+	static DeclareMemType MTYPE_JOY_KEY;
+
+	static DeclareMemType MTYPE_IDLE;
+	static DeclareMemType MTYPE_IDLE_PUMP;
+	static DeclareMemType MTYPE_IDLE_NETWORK;
+	static DeclareMemType MTYPE_IDLE_UPDATE_REGIONS;
+	static DeclareMemType MTYPE_IDLE_UPDATE_VIEWER_REGION;
+	static DeclareMemType MTYPE_IDLE_UPDATE_SURFACE;
+	static DeclareMemType MTYPE_IDLE_UPDATE_PARCEL_OVERLAY;
+	static DeclareMemType MTYPE_IDLE_AUDIO;
+
+	static DeclareMemType MTYPE_CACHE_PROCESS_PENDING;
+	static DeclareMemType MTYPE_CACHE_PROCESS_PENDING_ASKS;
+	static DeclareMemType MTYPE_CACHE_PROCESS_PENDING_REPLIES;
+
+	static DeclareMemType MTYPE_MESSAGE_CHECK_ALL;
+	static DeclareMemType MTYPE_MESSAGE_PROCESS_ACKS;
+
+	static DeclareMemType MTYPE_RENDER;
+	static DeclareMemType MTYPE_SLEEP;
+
+	static DeclareMemType MTYPE_NETWORK;
+	static DeclareMemType MTYPE_PHYSICS;
+	static DeclareMemType MTYPE_INTERESTLIST;
+
+	static DeclareMemType MTYPE_IMAGEBASE;
+	static DeclareMemType MTYPE_IMAGERAW;
+	static DeclareMemType MTYPE_IMAGEFORMATTED;
 	
-public:
+	static DeclareMemType MTYPE_APPFMTIMAGE;
-#if MEM_TRACK_TYPE
+	static DeclareMemType MTYPE_APPRAWIMAGE;
-	static S32 sCurDepth;
+	static DeclareMemType MTYPE_APPAUXRAWIMAGE;
-	static S32 sCurType;
+	
-	static S32 sType[MTYPE_MAX_DEPTH];
+	static DeclareMemType MTYPE_DRAWABLE;
-	static S32 sMemCount[MTYPE_NUM_TYPES];
+	
-	static S32 sMaxMemCount[MTYPE_NUM_TYPES];
+	static DeclareMemType MTYPE_OBJECT;
-	static S32 sNewCount[MTYPE_NUM_TYPES];
+	static DeclareMemType MTYPE_OBJECT_PROCESS_UPDATE;
-	static S32 sOverheadMem;
+	static DeclareMemType MTYPE_OBJECT_PROCESS_UPDATE_CORE;
-	static const char* sTypeDesc[MTYPE_NUM_TYPES];
+
-#endif
+	static DeclareMemType MTYPE_DISPLAY;
-	static S32 sTotalMem;
+	static DeclareMemType MTYPE_DISPLAY_UPDATE;
-	static S32 sMaxTotalMem;
+	static DeclareMemType MTYPE_DISPLAY_UPDATE_CAMERA;
+	static DeclareMemType MTYPE_DISPLAY_UPDATE_GEOM;
+	static DeclareMemType MTYPE_DISPLAY_SWAP;
+	static DeclareMemType MTYPE_DISPLAY_UPDATE_HUD;
+	static DeclareMemType MTYPE_DISPLAY_GEN_REFLECTION;
+	static DeclareMemType MTYPE_DISPLAY_IMAGE_UPDATE;
+	static DeclareMemType MTYPE_DISPLAY_STATE_SORT;
+	static DeclareMemType MTYPE_DISPLAY_SKY;
+	static DeclareMemType MTYPE_DISPLAY_RENDER_GEOM;
+	static DeclareMemType MTYPE_DISPLAY_RENDER_FLUSH;
+	static DeclareMemType MTYPE_DISPLAY_RENDER_UI;
+	static DeclareMemType MTYPE_DISPLAY_RENDER_ATTACHMENTS;
+
+	static DeclareMemType MTYPE_VERTEX_DATA;
+	static DeclareMemType MTYPE_VERTEX_CONSTRUCTOR;
+	static DeclareMemType MTYPE_VERTEX_DESTRUCTOR;
+	static DeclareMemType MTYPE_VERTEX_CREATE_VERTICES;
+	static DeclareMemType MTYPE_VERTEX_CREATE_INDICES;
+	static DeclareMemType MTYPE_VERTEX_DESTROY_BUFFER;	
+	static DeclareMemType MTYPE_VERTEX_DESTROY_INDICES;
+	static DeclareMemType MTYPE_VERTEX_UPDATE_VERTS;
+	static DeclareMemType MTYPE_VERTEX_UPDATE_INDICES;
+	static DeclareMemType MTYPE_VERTEX_ALLOCATE_BUFFER;
+	static DeclareMemType MTYPE_VERTEX_RESIZE_BUFFER;
+	static DeclareMemType MTYPE_VERTEX_MAP_BUFFER;
+	static DeclareMemType MTYPE_VERTEX_MAP_BUFFER_VERTICES;
+	static DeclareMemType MTYPE_VERTEX_MAP_BUFFER_INDICES;
+	static DeclareMemType MTYPE_VERTEX_UNMAP_BUFFER;
+	static DeclareMemType MTYPE_VERTEX_SET_STRIDE;
+	static DeclareMemType MTYPE_VERTEX_SET_BUFFER;
+	static DeclareMemType MTYPE_VERTEX_SETUP_VERTEX_BUFFER;
+	static DeclareMemType MTYPE_VERTEX_CLEANUP_CLASS;
+
+	static DeclareMemType MTYPE_SPACE_PARTITION;
+
+	static DeclareMemType MTYPE_PIPELINE;
+	static DeclareMemType MTYPE_PIPELINE_INIT;
+	static DeclareMemType MTYPE_PIPELINE_CREATE_BUFFERS;
+	static DeclareMemType MTYPE_PIPELINE_RESTORE_GL;
+	static DeclareMemType MTYPE_PIPELINE_UNLOAD_SHADERS;
+	static DeclareMemType MTYPE_PIPELINE_LIGHTING_DETAIL;
+	static DeclareMemType MTYPE_PIPELINE_GET_POOL_TYPE;
+	static DeclareMemType MTYPE_PIPELINE_ADD_POOL;
+	static DeclareMemType MTYPE_PIPELINE_ALLOCATE_DRAWABLE;
+	static DeclareMemType MTYPE_PIPELINE_ADD_OBJECT;
+	static DeclareMemType MTYPE_PIPELINE_CREATE_OBJECTS;
+	static DeclareMemType MTYPE_PIPELINE_UPDATE_MOVE;
+	static DeclareMemType MTYPE_PIPELINE_UPDATE_GEOM;
+	static DeclareMemType MTYPE_PIPELINE_MARK_VISIBLE;
+	static DeclareMemType MTYPE_PIPELINE_MARK_MOVED;
+	static DeclareMemType MTYPE_PIPELINE_MARK_SHIFT;
+	static DeclareMemType MTYPE_PIPELINE_SHIFT_OBJECTS;
+	static DeclareMemType MTYPE_PIPELINE_MARK_TEXTURED;
+	static DeclareMemType MTYPE_PIPELINE_MARK_REBUILD;
+	static DeclareMemType MTYPE_PIPELINE_UPDATE_CULL;
+	static DeclareMemType MTYPE_PIPELINE_STATE_SORT;
+	static DeclareMemType MTYPE_PIPELINE_POST_SORT;
+	
+	static DeclareMemType MTYPE_PIPELINE_RENDER_HUD_ELS;
+	static DeclareMemType MTYPE_PIPELINE_RENDER_HL;
+	static DeclareMemType MTYPE_PIPELINE_RENDER_GEOM;
+	static DeclareMemType MTYPE_PIPELINE_RENDER_GEOM_DEFFERRED;
+	static DeclareMemType MTYPE_PIPELINE_RENDER_GEOM_POST_DEF;
+	static DeclareMemType MTYPE_PIPELINE_RENDER_GEOM_SHADOW;
+	static DeclareMemType MTYPE_PIPELINE_RENDER_SELECT;
+	static DeclareMemType MTYPE_PIPELINE_REBUILD_POOLS;
+	static DeclareMemType MTYPE_PIPELINE_QUICK_LOOKUP;
+	static DeclareMemType MTYPE_PIPELINE_RENDER_OBJECTS;
+	static DeclareMemType MTYPE_PIPELINE_GENERATE_IMPOSTOR;
+	static DeclareMemType MTYPE_PIPELINE_RENDER_BLOOM;
+
+	static DeclareMemType MTYPE_UPKEEP_POOLS;
+
+	static DeclareMemType MTYPE_AVATAR;
+	static DeclareMemType MTYPE_AVATAR_MESH;
+	static DeclareMemType MTYPE_PARTICLES;
+	static DeclareMemType MTYPE_REGIONS;
+
+	static DeclareMemType MTYPE_INVENTORY;
+	static DeclareMemType MTYPE_INVENTORY_DRAW;
+	static DeclareMemType MTYPE_INVENTORY_BUILD_NEW_VIEWS;
+	static DeclareMemType MTYPE_INVENTORY_DO_FOLDER;
+	static DeclareMemType MTYPE_INVENTORY_POST_BUILD;
+	static DeclareMemType MTYPE_INVENTORY_FROM_XML;
+	static DeclareMemType MTYPE_INVENTORY_CREATE_NEW_ITEM;
+	static DeclareMemType MTYPE_INVENTORY_VIEW_INIT;
+	static DeclareMemType MTYPE_INVENTORY_VIEW_SHOW;
+	static DeclareMemType MTYPE_INVENTORY_VIEW_TOGGLE;
+
+	static DeclareMemType MTYPE_ANIMATION;
+	static DeclareMemType MTYPE_VOLUME;
+	static DeclareMemType MTYPE_PRIMITIVE;
+	
+	static DeclareMemType MTYPE_SCRIPT;
+	static DeclareMemType MTYPE_SCRIPT_RUN;
+	static DeclareMemType MTYPE_SCRIPT_BYTECODE;
+	
+	static DeclareMemType MTYPE_IO_PUMP;
+	static DeclareMemType MTYPE_IO_TCP;
+	static DeclareMemType MTYPE_IO_BUFFER;
+	static DeclareMemType MTYPE_IO_HTTP_SERVER;
+	static DeclareMemType MTYPE_IO_SD_SERVER;
+	static DeclareMemType MTYPE_IO_SD_CLIENT;
+	static DeclareMemType MTYPE_IO_URL_REQUEST;
+
+	static DeclareMemType MTYPE_DIRECTX_INIT;
+
+	static DeclareMemType MTYPE_TEMP1;
+	static DeclareMemType MTYPE_TEMP2;
+	static DeclareMemType MTYPE_TEMP3;
+	static DeclareMemType MTYPE_TEMP4;
+	static DeclareMemType MTYPE_TEMP5;
+	static DeclareMemType MTYPE_TEMP6;
+	static DeclareMemType MTYPE_TEMP7;
+	static DeclareMemType MTYPE_TEMP8;
+	static DeclareMemType MTYPE_TEMP9;
+
+	static DeclareMemType MTYPE_OTHER; // Special; used by display code
+
+	S32 mTypeIndex;
 };
 
 //----------------------------------------------------------------------------

indra/llimage/llimage.cpp

@@ -170,7 +170,7 @@ void LLImageBase::deleteData()
 // virtual
 U8* LLImageBase::allocateData(S32 size)
 {
-	LLMemType mt1((LLMemType::EMemType)mMemType);
+	LLMemType mt1(mMemType);
 	
 	if (size < 0)
 	{
@@ -209,7 +209,7 @@ U8* LLImageBase::reallocateData(S32 size)
 	if(mData && (mDataSize == size))
 		return mData;
 
-	LLMemType mt1((LLMemType::EMemType)mMemType);
+	LLMemType mt1(mMemType);
 	U8 *new_datap = (U8*)ALLOCATE_MEM(sPrivatePoolp, size);
 	if (!new_datap)
 	{
@@ -457,7 +457,7 @@ void LLImageRaw::clear(U8 r, U8 g, U8 b, U8 a)
 // Reverses the order of the rows in the image
 void LLImageRaw::verticalFlip()
 {
-	LLMemType mt1((LLMemType::EMemType)mMemType);
+	LLMemType mt1(mMemType);
 	S32 row_bytes = getWidth() * getComponents();
 	U8* line_buffer = new (std::nothrow) U8[row_bytes];
 	if (!line_buffer )
@@ -595,7 +595,7 @@ void LLImageRaw::composite( LLImageRaw* src )
 // Src and dst can be any size.  Src has 4 components.  Dst has 3 components.
 void LLImageRaw::compositeScaled4onto3(LLImageRaw* src)
 {
-	LLMemType mt1((LLMemType::EMemType)mMemType);
+	LLMemType mt1(mMemType);
 	llinfos << "compositeScaled4onto3" << llendl;
 
 	LLImageRaw* dst = this;  // Just for clarity.
@@ -846,7 +846,7 @@ void LLImageRaw::copyUnscaled3onto4( LLImageRaw* src )
 // Src and dst can be any size.  Src and dst have same number of components.
 void LLImageRaw::copyScaled( LLImageRaw* src )
 {
-	LLMemType mt1((LLMemType::EMemType)mMemType);
+	LLMemType mt1(mMemType);
 	LLImageRaw* dst = this;  // Just for clarity.
 
 	llassert_always( (1 == src->getComponents()) || (3 == src->getComponents()) || (4 == src->getComponents()) );
@@ -932,7 +932,7 @@ BOOL LLImageRaw::scaleDownWithoutBlending( S32 new_width, S32 new_height)
 
 BOOL LLImageRaw::scale( S32 new_width, S32 new_height, BOOL scale_image_data )
 {
-	LLMemType mt1((LLMemType::EMemType)mMemType);
+	LLMemType mt1(mMemType);
 	llassert((1 == getComponents()) || (3 == getComponents()) || (4 == getComponents()) );
 
 	S32 old_width = getWidth();

indra/llimage/llimage.h

@@ -35,7 +35,7 @@
 
 #include "lluuid.h"
 #include "llstring.h"
-#include "llmemory.h"
+#include "llmemtype.h"
 #include "llthread.h"
 #include "aithreadsafe.h"
 
@@ -162,7 +162,7 @@ private:
 
 	static LLPrivateMemoryPool* sPrivatePoolp ;
 public:
-	S16 mMemType; // debug
+	LLMemType::DeclareMemType& mMemType; // debug
 };
 
 // Raw representation of an image (used for textures, and other uncompressed formats

indra/llimage/llimagej2c.cpp

@@ -297,7 +297,7 @@ BOOL LLImageJ2C::decode(LLImageRaw *raw_imagep, F32 decode_time)
 // Returns TRUE to mean done, whether successful or not.
 BOOL LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 first_channel, S32 max_channel_count )
 {
-	LLMemType mt1((LLMemType::EMemType)mMemType);
+	LLMemType mt1(mMemType);
 
 	BOOL res = TRUE;
 	
@@ -347,7 +347,7 @@ BOOL LLImageJ2C::encode(const LLImageRaw *raw_imagep, F32 encode_time)
 
 BOOL LLImageJ2C::encode(const LLImageRaw *raw_imagep, const char* comment_text, F32 encode_time)
 {
-	LLMemType mt1((LLMemType::EMemType)mMemType);
+	LLMemType mt1(mMemType);
 	resetLastError();
 	BOOL res = mImpl->encodeImpl(*this, *raw_imagep, comment_text, encode_time, mReversible);
 	if (!mLastError.empty())
@@ -529,7 +529,7 @@ BOOL LLImageJ2C::loadAndValidate(const std::string &filename)
 
 BOOL LLImageJ2C::validate(U8 *data, U32 file_size)
 {
-	LLMemType mt1((LLMemType::EMemType)mMemType);
+	LLMemType mt1(mMemType);
 
 	resetLastError();
 	

indra/llmessage/llcachename.cpp

@@ -42,6 +42,7 @@
 #include "llsdserialize.h"
 #include "lluuid.h"
 #include "message.h"
+#include "llmemtype.h"
 
 #include <boost/regex.hpp>
 
@@ -771,6 +772,7 @@ bool LLCacheName::getIfThere(const LLUUID& id, std::string& fullname, BOOL& is_g
 // </edit>
 void LLCacheName::processPending()
 {
+	LLMemType mt_pp(LLMemType::MTYPE_CACHE_PROCESS_PENDING);
 	const F32 SECS_BETWEEN_PROCESS = 0.1f;
 	if(!impl.mProcessTimer.checkExpirationAndReset(SECS_BETWEEN_PROCESS))
 	{
@@ -873,8 +875,10 @@ std::string LLCacheName::getDefaultLastName()
 {
 	return "Resident";
 }
+
 void LLCacheName::Impl::processPendingAsks()
 {
+	LLMemType mt_ppa(LLMemType::MTYPE_CACHE_PROCESS_PENDING_ASKS);
 	sendRequest(_PREHASH_UUIDNameRequest, mAskNameQueue);
 	sendRequest(_PREHASH_UUIDGroupNameRequest, mAskGroupQueue);
 	mAskNameQueue.clear();
@@ -883,6 +887,7 @@ void LLCacheName::Impl::processPendingAsks()
 
 void LLCacheName::Impl::processPendingReplies()
 {
+	LLMemType mt_ppr(LLMemType::MTYPE_CACHE_PROCESS_PENDING_REPLIES);
 	// First call all the callbacks, because they might send messages.
 	for(ReplyQueue::iterator it = mReplyQueue.begin(); it != mReplyQueue.end(); ++it)
 	{

indra/llmessage/lliosocket.cpp

@@ -244,6 +244,7 @@ LLSocket::LLSocket() :
 	mPool(LLThread::tldata().mRootPool),
 	mPort(PORT_INVALID)
 {
+		LLMemType m1(LLMemType::MTYPE_IO_TCP);
 }
 
 LLSocket::~LLSocket()

indra/llmessage/message.cpp

@@ -86,6 +86,7 @@
 #include "v3math.h"
 #include "v4math.h"
 #include "lltransfertargetvfile.h"
+#include "llmemtype.h"
 
 // <edit>
 #include "llrand.h"
@@ -811,6 +812,7 @@ S32	LLMessageSystem::getReceiveBytes() const
 
 void LLMessageSystem::processAcks()
 {
+	LLMemType mt_pa(LLMemType::MTYPE_MESSAGE_PROCESS_ACKS);
 	F64 mt_sec = getMessageTimeSeconds();
 	{
 		gTransferManager.updateTransfers();
@@ -4048,6 +4050,7 @@ void LLMessageSystem::setTimeDecodesSpamThreshold( F32 seconds )
 // TODO: babbage: move gServicePump in to LLMessageSystem?
 bool LLMessageSystem::checkAllMessages(S64 frame_count, LLPumpIO* http_pump)
 {
+	LLMemType mt_cam(LLMemType::MTYPE_MESSAGE_CHECK_ALL);
 	if(checkMessages(frame_count))
 	{
 		return true;

indra/llrender/llgl.cpp

@@ -50,6 +50,7 @@
 #include "llmath.h"
 #include "m4math.h"
 #include "llstring.h"
+#include "llmemtype.h"
 #include "llstacktrace.h"
 
 #include "llglheaders.h"
@@ -2203,6 +2204,7 @@ void LLGLNamePool::release(GLuint name)
 //static
 void LLGLNamePool::upkeepPools()
 {
+	LLMemType mt(LLMemType::MTYPE_UPKEEP_POOLS);
 	for (tracker_t::instance_iter iter = beginInstances(); iter != endInstances(); ++iter)
 	{
 		LLGLNamePool & pool = *iter;

indra/llrender/llvertexbuffer.cpp

@@ -731,7 +731,7 @@ void LLVertexBuffer::unbind()
 //static
 void LLVertexBuffer::cleanupClass()
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_CLEANUP_CLASS);
 	unbind();
 	
 	sStreamIBOPool.cleanup();
@@ -750,41 +750,26 @@ void LLVertexBuffer::cleanupClass()
 
 S32 LLVertexBuffer::determineUsage(S32 usage)
 {
-	S32 ret_usage = usage;
+	if (LLRender::sGLCoreProfile)
-
-	if (!sEnableVBOs)
-	{
-		ret_usage = 0;
-	}
-	
-	if (usage == GL_STREAM_DRAW_ARB && !sUseStreamDraw)
-	{
-		ret_usage = 0;
-	}
-	
-	if (usage == GL_DYNAMIC_DRAW_ARB && sPreferStreamDraw)
-	{
-		ret_usage = GL_STREAM_DRAW_ARB;
-	}
-	
-	if (usage == 0 && LLRender::sGLCoreProfile)
 	{ //MUST use VBOs for all rendering
-		ret_usage = GL_STREAM_DRAW_ARB;
+		if(!usage)
+			usage = GL_STREAM_DRAW_ARB;
+	}
+	else if (!sEnableVBOs || !usage)
+	{
+		return 0;
 	}
 	
-	if (usage && usage != GL_STREAM_DRAW_ARB)
+	//Only stream_draw and dynamic_draw are supported when using VBOs, dynamic draw is the default.
-	{ //only stream_draw and dynamic_draw are supported when using VBOs, dynamic draw is the default
+	//Always use stream_draw VBO if mapping is disabled, or stream is enabled and preferred/expected
-		if (sDisableVBOMapping)
+	if( sDisableVBOMapping || (sUseStreamDraw && (sPreferStreamDraw || usage == GL_STREAM_DRAW_ARB)))
-		{ //always use stream draw if VBO mapping is disabled
+	{
-			ret_usage = GL_STREAM_DRAW_ARB;
+		return GL_STREAM_DRAW_ARB;
-		}
+	}
-		else
+	else
-		{
+	{
-			ret_usage = GL_DYNAMIC_DRAW_ARB;
+		return GL_DYNAMIC_DRAW_ARB;
-		}
 	}
-	
-	return ret_usage;
 }
 
 LLVertexBuffer::LLVertexBuffer(U32 typemask, S32 usage) :
@@ -812,7 +797,7 @@ LLVertexBuffer::LLVertexBuffer(U32 typemask, S32 usage) :
 	mMappable(false),
 	mFence(NULL)
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_CONSTRUCTOR);
 
 	if (mUsage == GL_DYNAMIC_DRAW_ARB && !sDisableVBOMapping)
 	{
@@ -880,7 +865,7 @@ S32 LLVertexBuffer::getSize() const
 //virtual
 LLVertexBuffer::~LLVertexBuffer()
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_DESTRUCTOR);
 	destroyGLBuffer();
 	destroyGLIndices();
 
@@ -997,7 +982,7 @@ void LLVertexBuffer::releaseIndices()
 
 void LLVertexBuffer::createGLBuffer(U32 size)
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_CREATE_VERTICES);
 	
 	if (mGLBuffer)
 	{
@@ -1028,7 +1013,7 @@ void LLVertexBuffer::createGLBuffer(U32 size)
 
 void LLVertexBuffer::createGLIndices(U32 size)
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_CREATE_INDICES);
 	
 	if (mGLIndices)
 	{
@@ -1064,7 +1049,7 @@ void LLVertexBuffer::createGLIndices(U32 size)
 
 void LLVertexBuffer::destroyGLBuffer()
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_DESTROY_BUFFER);
 	if (mGLBuffer)
 	{
 		if (mMappedDataUsingVBOs)
@@ -1085,7 +1070,7 @@ void LLVertexBuffer::destroyGLBuffer()
 
 void LLVertexBuffer::destroyGLIndices()
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_DESTROY_INDICES);
 	if (mGLIndices)
 	{
 		if (mMappedIndexDataUsingVBOs)
@@ -1106,7 +1091,7 @@ void LLVertexBuffer::destroyGLIndices()
 
 void LLVertexBuffer::updateNumVerts(S32 nverts)
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_UPDATE_VERTS);
 
 	llassert(nverts >= 0);
 
@@ -1128,7 +1113,7 @@ void LLVertexBuffer::updateNumVerts(S32 nverts)
 
 void LLVertexBuffer::updateNumIndices(S32 nindices)
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_UPDATE_INDICES);
 
 	llassert(nindices >= 0);
 
@@ -1144,7 +1129,7 @@ void LLVertexBuffer::updateNumIndices(S32 nindices)
 
 void LLVertexBuffer::allocateBuffer(S32 nverts, S32 nindices, bool create)
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_ALLOCATE_BUFFER);
 	
 	stop_glerror();
 
@@ -1265,7 +1250,7 @@ void LLVertexBuffer::resizeBuffer(S32 newnverts, S32 newnindices)
 	llassert(newnverts >= 0);
 	llassert(newnindices >= 0);
 
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_RESIZE_BUFFER);
 	
 	updateNumVerts(newnverts);		
 	updateNumIndices(newnindices);
@@ -1313,7 +1298,7 @@ static LLFastTimer::DeclareTimer FTM_VBO_MAP_BUFFER("VBO Map");
 volatile U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 index, S32 count, bool map_range)
 {
 	bindGLBuffer(true);
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_MAP_BUFFER);
 	if (mFinal)
 	{
 		llerrs << "LLVertexBuffer::mapVeretxBuffer() called on a finalized buffer." << llendl;
@@ -1362,6 +1347,7 @@ volatile U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 index, S32 count, boo
 
 		if (!mVertexLocked)
 		{
+			LLMemType mt_v(LLMemType::MTYPE_VERTEX_MAP_BUFFER_VERTICES);
 			mVertexLocked = true;
 			sMappedCount++;
 			stop_glerror();	
@@ -1492,7 +1478,7 @@ static LLFastTimer::DeclareTimer FTM_VBO_MAP_INDEX("IBO Map");
 
 volatile U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range)
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_MAP_BUFFER);
 	bindGLIndices(true);
 	if (mFinal)
 	{
@@ -1539,7 +1525,7 @@ volatile U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range
 
 		if (!mIndexLocked)
 		{
-			//LLMemType mt_v(LLMemType::MTYPE_VERTEX_MAP_BUFFER_INDICES);
+			LLMemType mt_v(LLMemType::MTYPE_VERTEX_MAP_BUFFER_INDICES);
 
 			mIndexLocked = true;
 			sMappedCount++;
@@ -1663,7 +1649,7 @@ static LLFastTimer::DeclareTimer FTM_IBO_FLUSH_RANGE("Flush IBO Range");
 
 void LLVertexBuffer::unmapBuffer()
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_UNMAP_BUFFER);
 	if (!useVBOs())
 	{
 		return ; //nothing to unmap
@@ -2007,7 +1993,7 @@ void LLVertexBuffer::setBuffer(U32 data_mask)
 {
 	flush();
 
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_SET_BUFFER);
 	//set up pointers if the data mask is different ...
 	bool setup = (sLastMask != data_mask);
 
@@ -2149,7 +2135,7 @@ void LLVertexBuffer::setBuffer(U32 data_mask)
 // virtual (default)
 void LLVertexBuffer::setupVertexBuffer(U32 data_mask)
 {
-	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	LLMemType mt2(LLMemType::MTYPE_VERTEX_SETUP_VERTEX_BUFFER);
 	stop_glerror();
 	volatile U8* base = useVBOs() ? (U8*) mAlignedOffset : mMappedData;
 

indra/newview/app_settings/settings.xml

@@ -8043,6 +8043,17 @@
       <key>Value</key>
       <integer>512</integer>
     </map>
+    <key>MemProfiling</key>
+    <map>
+      <key>Comment</key>
+      <string>You want to use tcmalloc's memory profiling options.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>  
     <key>MenuAccessKeyTime</key>
     <map>
       <key>Comment</key>

indra/newview/llagentwearables.cpp

@@ -564,7 +564,8 @@ BOOL LLAgentWearables::isWearableCopyable(LLWearableType::EType type, U32 index)
 
 BOOL LLAgentWearables::areWearablesLoaded() const
 {
-	if(gSavedSettings.getBOOL("RenderUnloadedAvatar"))
+	static const LLCachedControl<bool> rener_unloaded_avatar("RenderUnloadedAvatar");
+	if(rener_unloaded_avatar)
 		return TRUE;
 	return mWearablesLoaded;
 }

indra/newview/llappviewer.cpp

@@ -629,6 +629,8 @@ bool LLAppViewer::init()
 	initMaxHeapSize() ;
 
 	LLPrivateMemoryPoolManager::initClass((BOOL)gSavedSettings.getBOOL("MemoryPrivatePoolEnabled"), (U32)gSavedSettings.getU32("MemoryPrivatePoolSize")) ;
+
+    mAlloc.setProfilingEnabled(gSavedSettings.getBOOL("MemProfiling"));
     // *NOTE:Mani - LLCurl::initClass is not thread safe. 
     // Called before threads are created.
     LLCurl::initClass(gSavedSettings.getBOOL("CurlUseMultipleThreads"));
@@ -1022,8 +1024,10 @@ static LLFastTimer::DeclareTimer FTM_PUMP_SERVICE("Service");
 static LLFastTimer::DeclareTimer FTM_SERVICE_CALLBACK("Callback");
 static LLFastTimer::DeclareTimer FTM_AGENT_AUTOPILOT("Autopilot");
 static LLFastTimer::DeclareTimer FTM_AGENT_UPDATE("Update");
+
 bool LLAppViewer::mainLoop()
 {
+	LLMemType mt1(LLMemType::MTYPE_MAIN);
 	mMainloopTimeout = new LLWatchdogTimeout();
 	// *FIX:Mani - Make this a setting, once new settings exist in this branch.
 	
@@ -1041,7 +1045,6 @@ bool LLAppViewer::mainLoop()
 	LLVoiceChannel::initClass();
 	LLVoiceClient::init(gServicePump);
 				
-	LLMemType mt1(LLMemType::MTYPE_MAIN);
 	LLTimer frameTimer,idleTimer;
 	LLTimer debugTime;
 	LLFrameTimer memCheckTimer;
@@ -1114,6 +1117,7 @@ bool LLAppViewer::mainLoop()
 					&& !gViewerWindow->getShowProgress()
 					&& !gFocusMgr.focusLocked())
 				{
+					LLMemType mjk(LLMemType::MTYPE_JOY_KEY);
 					joystick->scanJoystick();
 					gKeyboard->scanKeyboard();
 					if(isCrouch)
@@ -1133,6 +1137,7 @@ bool LLAppViewer::mainLoop()
 
 					if (gAres != NULL && gAres->isInitialized())
 					{
+						LLMemType mt_ip(LLMemType::MTYPE_IDLE_PUMP);
 						pingMainloopTimeout("Main:ServicePump");				
 						LLFastTimer t4(FTM_PUMP);
 						{
@@ -1187,6 +1192,7 @@ bool LLAppViewer::mainLoop()
 
 			// Sleep and run background threads
 			{
+				LLMemType mt_sleep(LLMemType::MTYPE_SLEEP);
 				LLFastTimer t2(FTM_SLEEP);
 				static const LLCachedControl<bool> run_multiple_threads("RunMultipleThreads",false);
 
@@ -3706,6 +3712,7 @@ static LLFastTimer::DeclareTimer FTM_VLMANAGER("VL Manager");
 ///////////////////////////////////////////////////////
 void LLAppViewer::idle()
 {
+	LLMemType mt_idle(LLMemType::MTYPE_IDLE);
 	pingMainloopTimeout("Main:Idle");
 	
 	// Update frame timers
@@ -4286,6 +4293,7 @@ static LLFastTimer::DeclareTimer FTM_DYNAMIC_THROTTLE("Dynamic Throttle");
 static LLFastTimer::DeclareTimer FTM_CHECK_REGION_CIRCUIT("Check Region Circuit");
 void LLAppViewer::idleNetwork()
 {
+	LLMemType mt_in(LLMemType::MTYPE_IDLE_NETWORK);
 	pingMainloopTimeout("idleNetwork");
 
 	gObjectList.mNumNewObjects = 0;

indra/newview/llappviewer.h

@@ -33,7 +33,8 @@
 #ifndef LL_LLAPPVIEWER_H
 #define LL_LLAPPVIEWER_H
 
-#include "llsys.h"				// LLOSInfo
+#include "llallocator.h"
+#include "llsys.h"			// for LLOSInfo
 #include "llviewercontrol.h"	// settings_map_type
 
 class LLTextureCache;
@@ -158,6 +159,7 @@ public:
 	// *NOTE:Mani Fix this for login abstraction!!
 	void handleLoginComplete();
 
+    LLAllocator & getAllocator() { return mAlloc; }
 	void addOnIdleCallback(const boost::function<void()>& cb); // add a callback to fire (once) when idle
 
 	void purgeCache(); // Clear the local cache. 
@@ -245,6 +247,7 @@ private:
 	bool mAgentRegionLastAlive;
 	LLUUID mAgentRegionLastID;
 
+    LLAllocator mAlloc;
 
 	LLFrameTimer mMemCheckTimer;
 	

indra/newview/llconsole.cpp

@@ -160,7 +160,7 @@ void LLConsole::draw()
 	F32 skip_time = cur_time - mLinePersistTime;
 	F32 fade_time = cur_time - mFadeTime;
 
-	U32 max_lines = gSavedSettings.getS32("ConsoleMaxLines");
+	static const LLCachedControl<S32> max_lines("ConsoleMaxLines");
 	U32 num_lines=0;
 
 	paragraph_t::reverse_iterator paragraph_it;
@@ -170,7 +170,7 @@ void LLConsole::draw()
 	while (!mParagraphs.empty() && paragraph_it != mParagraphs.rend())
 	{
 		num_lines += (*paragraph_it)->mLines.size();
-		if(num_lines > max_lines 
+		if(num_lines > (U32)max_lines.get()
 			|| ( (mLinePersistTime > (F32)0.f) && ((*paragraph_it)->mAddTime - skip_time)/(mLinePersistTime - mFadeTime) <= (F32)0.f)) 
 		{							//All lines above here are done.  Lose them.
 			for (U32 i=0;i<paragraph_num;i++)
@@ -198,8 +198,10 @@ void LLConsole::draw()
 
 	LLUIImagePtr imagep = LLUI::getUIImage("rounded_square.tga");
 
-	F32 console_opacity = llclamp(gSavedSettings.getF32("ConsoleBackgroundOpacity"), 0.f, 1.f);
+	static const LLCachedControl<F32> console_background_opacity("ConsoleBackgroundOpacity");
-	LLColor4 color = gColors.getColor("ConsoleBackground");
+	F32 console_opacity = llclamp(console_background_opacity.get(), 0.f, 1.f);
+	static const LLCachedControl<LLColor4> console_background(gColors,"ConsoleBackground");
+	LLColor4 color = console_background;
 	color.mV[VALPHA] *= console_opacity;
 
 	F32 line_height = mFont->getLineHeight();

indra/newview/lldrawpoolalpha.cpp

@@ -107,11 +107,12 @@ void LLDrawPoolAlpha::renderDeferred(S32 pass)
 
 S32 LLDrawPoolAlpha::getNumPostDeferredPasses() 
 { 
+	static const LLCachedControl<bool> render_depth_of_field("RenderDepthOfField");
 	if (LLPipeline::sImpostorRender)
 	{ //skip depth buffer filling pass when rendering impostors
 		return 1;
 	}
-	else if (gSavedSettings.getBOOL("RenderDepthOfField"))
+	else if (render_depth_of_field)
 	{
 		return 2; 
 	}

indra/newview/lldrawpoolterrain.cpp

@@ -128,7 +128,8 @@ U32 LLDrawPoolTerrain::getVertexDataMask()
 void LLDrawPoolTerrain::prerender()
 {
 	mVertexShaderLevel = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_ENVIRONMENT);
-	sDetailMode = gSavedSettings.getS32("RenderTerrainDetail");
+	static const LLCachedControl<S32> render_terrain_detail("RenderTerrainDetail");
+	sDetailMode = render_terrain_detail;
 }
 
 void LLDrawPoolTerrain::beginRenderPass( S32 pass )

indra/newview/lldrawpoolwater.cpp

@@ -573,7 +573,8 @@ void LLDrawPoolWater::shade()
 
 	mWaterNormp->addTextureStats(1024.f*1024.f);
 	gGL.getTexUnit(bumpTex)->bind(mWaterNormp) ;
-	if (gSavedSettings.getBOOL("RenderWaterMipNormal"))
+	static const LLCachedControl<bool> render_water_mip_normal("RenderWaterMipNormal");
+	if (render_water_mip_normal)
 	{
 		mWaterNormp->setFilteringOption(LLTexUnit::TFO_ANISOTROPIC);
 	}

indra/newview/llmemoryview.cpp

@@ -32,37 +32,28 @@
 
 #include "llviewerprecompiledheaders.h"
 
-#include "indra_constants.h"
 #include "llmemoryview.h"
 
-#include "llrect.h"
+#include "llappviewer.h"
-#include "llerror.h"
+#include "llallocator_heap_profile.h"
-#include "llgl.h"
+#include "llgl.h"						// LLGLSUIDefault
-#include "llmath.h"
+#include "llviewerwindow.h"
-#include "llfontgl.h"
-#include "llmemtype.h"
-
-#include "llcharacter.h"
-#include "llui.h"
 #include "llviewercontrol.h"
-#include "llstat.h"
 
-#include "llfasttimer.h"
+#include <sstream>
+#include <boost/algorithm/string/split.hpp>
+
+#include "llmemory.h"
 
 
 
 LLMemoryView::LLMemoryView(const std::string& name, const LLRect& rect)
 :	LLView(name, rect, TRUE),
-mDelay(120)
+	mPaused(FALSE),
+	//mDelay(120),
+    mAlloc(NULL)
 {
 	setVisible(FALSE);
-	mDumpTimer.reset();
-
-#ifdef MEM_DUMP_DATA
-	// clear out file.
-	LLFILE *dump = LLFile::fopen("memusagedump.txt", "w");
-	fclose(dump);
-#endif
 }
 
 LLMemoryView::~LLMemoryView()
@@ -79,6 +70,7 @@ BOOL LLMemoryView::handleMouseDown(S32 x, S32 y, MASK mask)
 	}
 	else
 	{
+		mPaused = !mPaused;
 	}
 	return TRUE;
 }
@@ -94,62 +86,145 @@ BOOL LLMemoryView::handleHover(S32 x, S32 y, MASK mask)
 	return FALSE;
 }
 
-//////////////////////////////////////////////////////////////////////////////
+void LLMemoryView::refreshProfile()
-
-struct mtv_display_info {
-	S32 memtype;
-	const char *desc;
-	const LLColor4 *color;
-};
-
-static const LLColor4 red0(0.5f, 0.0f, 0.0f, 1.0f);
-
-static const struct mtv_display_info mtv_display_table[] =
 {
-	{ LLMemType::MTYPE_INIT,			"Init", 			&LLColor4::white },
+	/*
-	{ LLMemType::MTYPE_STARTUP,			"Startup", 			&LLColor4::cyan1 },
+    LLAllocator & alloc = LLAppViewer::instance()->getAllocator();
-	{ LLMemType::MTYPE_MAIN,			"Main", 			&LLColor4::cyan2 },
+    if(alloc.isProfiling()) {
-	{ LLMemType::MTYPE_IMAGEBASE,		"ImageBase",		&LLColor4::yellow1 },
+        std::string profile_text = alloc.getRawProfile();
-	{ LLMemType::MTYPE_IMAGERAW,		"ImageRaw", 		&LLColor4::yellow2 },
-	{ LLMemType::MTYPE_IMAGEFORMATTED,	"ImageFmtd",		&LLColor4::yellow3 },
-	{ LLMemType::MTYPE_APPFMTIMAGE,		"ViewerImageFmt",	&LLColor4::orange1 },
-	{ LLMemType::MTYPE_APPRAWIMAGE,		"ViewerImageRaw",	&LLColor4::orange2 },
-	{ LLMemType::MTYPE_APPAUXRAWIMAGE,	"ViewerImageAux",	&LLColor4::orange3 },
-	{ LLMemType::MTYPE_DRAWABLE,		"Drawable", 		&LLColor4::green1 },
-	{ LLMemType::MTYPE_OBJECT,			"ViewerObject",		&LLColor4::green2 },
-	{ LLMemType::MTYPE_PIPELINE,		"Pipeline",			&LLColor4::green3 },
-	{ LLMemType::MTYPE_PARTICLES,		"Particles",		&LLColor4::green4 },
-	{ LLMemType::MTYPE_SPACE_PARTITION,	"Space Partition",	&LLColor4::blue2 },
-	{ LLMemType::MTYPE_VERTEX_DATA,		"Vertex Buffer",	&LLColor4::blue3 },
-	{ LLMemType::MTYPE_AVATAR,			"Avatar",			&LLColor4::purple1 },
-	{ LLMemType::MTYPE_AVATAR_MESH,		"Avatar Mesh",		&LLColor4::purple2 },
-	{ LLMemType::MTYPE_ANIMATION,		"Animation",		&LLColor4::purple3 },
-	{ LLMemType::MTYPE_REGIONS,			"Regions",			&LLColor4::blue1 },
-	{ LLMemType::MTYPE_VOLUME,			"Volume",			&LLColor4::pink1 },
-	{ LLMemType::MTYPE_PRIMITIVE,		"Profile",			&LLColor4::pink2 },
- 	{ LLMemType::MTYPE_TEMP1,			"Temp1",			&LLColor4::red1 },
- 	{ LLMemType::MTYPE_TEMP2,			"Temp2",			&LLColor4::magenta1 },
- 	{ LLMemType::MTYPE_TEMP3,			"Temp3",			&LLColor4::red2 },
- 	{ LLMemType::MTYPE_TEMP4,			"Temp4",			&LLColor4::magenta2 },
- 	{ LLMemType::MTYPE_TEMP5,			"Temp5",			&LLColor4::red3 },
- 	{ LLMemType::MTYPE_TEMP6,			"Temp6",			&LLColor4::magenta3 },
- 	{ LLMemType::MTYPE_TEMP7,			"Temp7",			&LLColor4::red4 },
- 	{ LLMemType::MTYPE_TEMP8,			"Temp8",			&LLColor4::magenta4 },
 
- 	{ LLMemType::MTYPE_OTHER,			"Other",			&red0 },
+        boost::algorithm::split(mLines, profile_text, boost::bind(std::equal_to<llwchar>(), '\n', _1));
-};
+    } else {
-static const int MTV_DISPLAY_NUM  = LL_ARRAY_SIZE(mtv_display_table);
+        mLines.clear();
+    }
+	*/
+    if (mAlloc == NULL) {
+        mAlloc = &LLAppViewer::instance()->getAllocator();
+    }
+
+	mLines.clear();
+
+ 	if(mAlloc->isProfiling()) 
+	{
+		const LLAllocatorHeapProfile &prof = mAlloc->getProfile();
+		for(size_t i = 0; i < prof.mLines.size(); ++i)
+		{
+			std::stringstream ss;
+			ss << "Unfreed Mem: " << (prof.mLines[i].mLiveSize >> 20) << " M     Trace: ";
+			for(size_t k = 0; k < prof.mLines[i].mTrace.size(); ++k)
+			{
+				ss << LLMemType::getNameFromID(prof.mLines[i].mTrace[k]) << "  ";
+			}
+			mLines.push_back(utf8string_to_wstring(ss.str()));
+		}
+	}
+}
 
 void LLMemoryView::draw()
 {
-	std::string tdesc;
+	const S32 UPDATE_INTERVAL = 60;
-	S32 width = getRect().getWidth();
+	const S32 MARGIN_AMT = 10; 
-	S32 height = getRect().getHeight();
+	static S32 curUpdate = UPDATE_INTERVAL;
+	static const LLCachedControl<LLColor4> console_background(gColors,"ConsoleBackground");
+    static LLColor4 s_console_color = console_background;
+
+	// setup update interval
+	if (curUpdate >= UPDATE_INTERVAL)
+	{
+		refreshProfile();
+		curUpdate = 0;
+	}
+	curUpdate++;
+
+	// setup window properly
+	S32 height = (S32) (gViewerWindow->getWindowRectScaled().getHeight()*0.75f);
+	S32 width = (S32) (gViewerWindow->getWindowRectScaled().getWidth() * 0.9f);
+	setRect(LLRect().setLeftTopAndSize(getRect().mLeft, getRect().mTop, width, height));
 	
+	// setup window color
+	static const LLCachedControl<F32> console_background_opacity("ConsoleBackgroundOpacity");
+	F32 console_opacity = llclamp(console_background_opacity.get(), 0.f, 1.f);
+	LLColor4 color = s_console_color;
+	color.mV[VALPHA] *= console_opacity;
+
 	LLGLSUIDefault gls_ui;
 	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-	gl_rect_2d(0, height, width, 0, LLColor4(0.f, 0.f, 0.f, 0.25f));
+	gl_rect_2d(0, height, width, 0, color);
 	
+    LLFontGL * font = LLFontGL::getFontSansSerifSmall(); 
+
+	// draw remaining lines
+	F32 y_pos = 0.f;
+    F32 y_off = 0.f;
+
+	F32 line_height = font->getLineHeight();
+    S32 target_width = width - 2 * MARGIN_AMT;
+
+	// cut off lines on bottom
+	U32 max_lines = U32((height - 2 * line_height) / line_height);
+	y_pos = height - MARGIN_AMT - line_height;
+    y_off = 0.f;
+
+#if !MEM_TRACK_MEM
+	std::vector<LLWString>::const_iterator end = mLines.end();
+    if(mLines.size() > max_lines) {
+        end = mLines.begin() + max_lines;
+    }
+    for (std::vector<LLWString>::const_iterator i = mLines.begin(); i != end; ++i)
+	{
+		font->render(*i, 0, MARGIN_AMT, y_pos -  y_off,
+            LLColor4::white,
+			LLFontGL::LEFT, 
+			LLFontGL::BASELINE,
+            LLFontGL::NORMAL,
+			LLFontGL::DROP_SHADOW,
+			S32_MAX,
+			target_width
+			);
+		y_off += line_height;
+	}
+
+#else
+	LLMemTracker::getInstance()->preDraw(mPaused) ;
+
+	{
+		F32 x_pos = MARGIN_AMT ;
+		U32 lines = 0 ;
+		const char* str = LLMemTracker::getInstance()->getNextLine() ;
+		while(str != NULL)
+		{
+			lines++ ;
+			font->renderUTF8(str, 0, x_pos, y_pos -  y_off,
+				LLColor4::white,
+				LLFontGL::LEFT, 
+				LLFontGL::BASELINE,
+				LLFontGL::NORMAL,
+				LLFontGL::DROP_SHADOW,
+				S32_MAX,
+				target_width,
+				NULL, FALSE);
+		
+			str = LLMemTracker::getInstance()->getNextLine() ;
+			y_off += line_height;
+
+			if(lines >= max_lines)
+			{
+				lines = 0 ;
+				x_pos += 512.f ;
+				if(x_pos + 512.f > target_width)
+				{
+					break ;
+				}
+
+				y_pos = height - MARGIN_AMT - line_height;
+				y_off = 0.f;
+			}
+		}
+	}
+
+	LLMemTracker::getInstance()->postDraw() ;
+#endif
+
 #if MEM_TRACK_TYPE
 
 	S32 left, top, right, bottom;
@@ -267,40 +342,3 @@ void LLMemoryView::draw()
 	
 	LLView::draw();
 }
-
-void LLMemoryView::setDataDumpInterval(float delay)
-{
-	mDelay = delay;
-}
-
-void LLMemoryView::dumpData()
-{
-#if MEM_TRACK_TYPE && MEM_DUMP_DATA
-	if (mDelay && (mDumpTimer.getElapsedTimeF32() > mDelay ))
-	{
-		// reset timer
-		mDumpTimer.reset();
-		// append dump info to text file
-		LLFILE *dump = LLFile::fopen("memusagedump.txt", "a");
-
-		if (dump)
-		{
-			// write out total memory usage
-			fprintf (dump, "Total memory in use = %09d (%03d MB)\n", LLMemType::sTotalMem, LLMemType::sTotalMem>>20);
-			fprintf (dump, "High Water Mark = %09d (%03d MB)\n\n", LLMemType::sMaxTotalMem, LLMemType::sMaxTotalMem>>20);
-			// dump out usage of 'new' for each memory type
-			for (S32 i=0; i<LLMemType::MTYPE_NUM_TYPES; i++)
-			{
-				if (LLMemType::sMemCount[i])
-				{
-					std::string outData = llformat("MEM: % 20s %09d %03d MB (%09d %03d MB) in %06d News", LLMemType::sTypeDesc[i], LLMemType::sMemCount[i], LLMemType::sMemCount[i]>>20, LLMemType::sMaxMemCount[i], LLMemType::sMaxMemCount[i]>>20, LLMemType::sNewCount[i]);
-					fprintf (dump, "%s\n", outData.c_str());
-				}
-			}
-			fprintf (dump, "\n\n");
-
-			fclose(dump);
-		}
-	}
-#endif
-}

indra/newview/llmemoryview.h

@@ -35,6 +35,8 @@
 
 #include "llview.h"
 
+class LLAllocator;
+
 class LLMemoryView : public LLView
 {
 public:
@@ -46,14 +48,13 @@ public:
 	virtual BOOL handleHover(S32 x, S32 y, MASK mask);
 	virtual void draw();
 
-private:
+	void refreshProfile();
-	void setDataDumpInterval(float delay);
-	void dumpData();
-
-	float mDelay;
-	LLFrameTimer mDumpTimer;
 
 private:
+    std::vector<LLWString> mLines;
+	LLAllocator* mAlloc;
+	BOOL mPaused ;
+
 };
 
 #endif

indra/newview/llmeshrepository.cpp

@@ -2240,7 +2240,8 @@ S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_para
 
 void LLMeshRepository::notifyLoadedMeshes()
 { //called from main thread
-	LLMeshRepoThread::sMaxConcurrentRequests = gSavedSettings.getU32("MeshMaxConcurrentRequests");
+	static const LLCachedControl<U32> max_concurrent_requests("MeshMaxConcurrentRequests");
+	LLMeshRepoThread::sMaxConcurrentRequests = max_concurrent_requests;
 
 #if MESH_IMPORT
 	//clean up completed upload threads
@@ -3580,7 +3581,8 @@ void LLMeshRepository::buildPhysicsMesh(LLModel::Decomposition& decomp)
 bool LLMeshRepository::meshUploadEnabled()
 {
 	LLViewerRegion *region = gAgent.getRegion();
-	if(gSavedSettings.getBOOL("MeshEnabled") &&
+	static const LLCachedControl<bool> mesh_enabled("MeshEnabled");
+	if(mesh_enabled &&
 	   region)
 	{
 		return region->meshUploadEnabled();
@@ -3591,7 +3593,8 @@ bool LLMeshRepository::meshUploadEnabled()
 bool LLMeshRepository::meshRezEnabled()
 {
 	LLViewerRegion *region = gAgent.getRegion();
-	if(gSavedSettings.getBOOL("MeshEnabled") && 
+	static const LLCachedControl<bool> mesh_enabled("MeshEnabled");
+	if(mesh_enabled && 
 	   region)
 	{
 		return region->meshRezEnabled();

indra/newview/llpanelmaininventory.cpp

@@ -56,10 +56,10 @@ const S32 INV_FINDER_WIDTH = 160;
 const S32 INV_FINDER_HEIGHT = 408;
 
 //BOOL LLInventoryView::sOpenNextNewItem = FALSE;
-class LLInventoryViewFinder : public LLFloater
+class LLFloaterInventoryFinder : public LLFloater
 {
 public:
-	LLInventoryViewFinder(const std::string& name,
+	LLFloaterInventoryFinder(const std::string& name,
 						const LLRect& rect,
 						LLInventoryView* inventory_view);
 	virtual void draw();
@@ -116,6 +116,7 @@ LLInventoryView::LLInventoryView(const std::string& name,
 
 void LLInventoryView::init(LLInventoryModel* inventory)
 {
+	LLMemType mt(LLMemType::MTYPE_INVENTORY_VIEW_INIT);
 	// Callbacks
 	init_inventory_actions(this);
 
@@ -497,7 +498,7 @@ void LLInventoryView::updateSortControls()
 
 void LLInventoryView::resetFilters()
 {
-	LLInventoryViewFinder *finder = getFinder();
+	LLFloaterInventoryFinder *finder = getFinder();
 	getActivePanel()->getFilter()->resetDefault();
 	if (finder)
 	{
@@ -531,7 +532,7 @@ void LLInventoryView::onClearSearch(void* user_data)
 
 	if (finder)
 	{
-		LLInventoryViewFinder::selectAllTypes(finder);
+		LLFloaterInventoryFinder::selectAllTypes(finder);
 	}
 
 	// re-open folders that were initially open
@@ -678,7 +679,7 @@ void LLInventoryView::onQuickFilterCommit(LLUICtrl* ctrl, void* user_data)
 
 
 	// Force the filters window to update itself, if it's open.
-	LLInventoryViewFinder* finder = view->getFinder();
+	LLFloaterInventoryFinder* finder = view->getFinder();
 	if( finder )
 	{
 		finder->updateElementsFromFilter();
@@ -897,7 +898,7 @@ void LLInventoryView::onFilterSelected(void* userdata, bool from_click)
 	LLInventoryView* self = (LLInventoryView*) userdata;
 	LLInventoryFilter* filter;
 
-	LLInventoryViewFinder *finder = self->getFinder();
+	LLFloaterInventoryFinder *finder = self->getFinder();
 	// Find my index
 	self->mActivePanel = (LLInventoryPanel*)self->childGetVisibleTab("inventory filter tabs");
 
@@ -1016,10 +1017,11 @@ void LLInventoryView::setFilterTextFromFilter()
 
 void LLInventoryView::toggleFindOptions()
 {
+	LLMemType mt(LLMemType::MTYPE_INVENTORY_VIEW_TOGGLE);
 	LLFloater *floater = getFinder();
 	if (!floater)
 	{
-		LLInventoryViewFinder * finder = new LLInventoryViewFinder(std::string("Inventory Finder"),
+		LLFloaterInventoryFinder * finder = new LLFloaterInventoryFinder(std::string("Inventory Finder"),
 										LLRect(getRect().mLeft - INV_FINDER_WIDTH, getRect().mTop, getRect().mLeft, getRect().mTop - INV_FINDER_HEIGHT),
 										this);
 		mFinderHandle = finder->getHandle();
@@ -1039,15 +1041,15 @@ void LLInventoryView::toggleFindOptions()
 	}
 }
 ///----------------------------------------------------------------------------
-/// LLInventoryViewFinder
+/// LLFloaterInventoryFinder
 ///----------------------------------------------------------------------------
-LLInventoryViewFinder* LLInventoryView::getFinder() 
+LLFloaterInventoryFinder* LLInventoryView::getFinder() 
 { 
-	return (LLInventoryViewFinder*)mFinderHandle.get();
+	return (LLFloaterInventoryFinder*)mFinderHandle.get();
 }
 
 
-LLInventoryViewFinder::LLInventoryViewFinder(const std::string& name,
+LLFloaterInventoryFinder::LLFloaterInventoryFinder(const std::string& name,
 						const LLRect& rect,
 						LLInventoryView* inventory_view) :
 	LLFloater(name, rect, std::string("Filters"), RESIZE_NO,
@@ -1061,7 +1063,7 @@ LLInventoryViewFinder::LLInventoryViewFinder(const std::string& name,
 	updateElementsFromFilter();
 }
 
-BOOL LLInventoryViewFinder::postBuild()
+BOOL LLFloaterInventoryFinder::postBuild()
 {
 	childSetAction("All", selectAllTypes, this);
 	childSetAction("None", selectNoTypes, this);
@@ -1082,9 +1084,9 @@ BOOL LLInventoryViewFinder::postBuild()
 }
 
 
-void LLInventoryViewFinder::onCheckSinceLogoff(LLUICtrl *ctrl, void *user_data)
+void LLFloaterInventoryFinder::onCheckSinceLogoff(LLUICtrl *ctrl, void *user_data)
 {
-	LLInventoryViewFinder *self = (LLInventoryViewFinder *)user_data;
+	LLFloaterInventoryFinder *self = (LLFloaterInventoryFinder *)user_data;
 	if (!self) return;
 
 	bool since_logoff= self->childGetValue("check_since_logoff");
@@ -1096,9 +1098,9 @@ void LLInventoryViewFinder::onCheckSinceLogoff(LLUICtrl *ctrl, void *user_data)
 	}	
 }
 
-void LLInventoryViewFinder::onTimeAgo(LLUICtrl *ctrl, void *user_data)
+void LLFloaterInventoryFinder::onTimeAgo(LLUICtrl *ctrl, void *user_data)
 {
-	LLInventoryViewFinder *self = (LLInventoryViewFinder *)user_data;
+	LLFloaterInventoryFinder *self = (LLFloaterInventoryFinder *)user_data;
 	if (!self) return;
 	
 	bool since_logoff=true;
@@ -1109,13 +1111,13 @@ void LLInventoryViewFinder::onTimeAgo(LLUICtrl *ctrl, void *user_data)
 	self->childSetValue("check_since_logoff", since_logoff);
 }
 
-void LLInventoryViewFinder::changeFilter(LLInventoryFilter* filter)
+void LLFloaterInventoryFinder::changeFilter(LLInventoryFilter* filter)
 {
 	mFilter = filter;
 	updateElementsFromFilter();
 }
 
-void LLInventoryViewFinder::updateElementsFromFilter()
+void LLFloaterInventoryFinder::updateElementsFromFilter()
 {
 	if (!mFilter)
 		return;
@@ -1146,8 +1148,9 @@ void LLInventoryViewFinder::updateElementsFromFilter()
 	mSpinSinceDays->set((F32)(hours / 24));
 }
 
-void LLInventoryViewFinder::draw()
+void LLFloaterInventoryFinder::draw()
 {
+	LLMemType mt(LLMemType::MTYPE_INVENTORY_DRAW);
 	U32 filter = 0xffffffff;
 	BOOL filtered_by_all_types = TRUE;
 
@@ -1253,7 +1256,7 @@ void LLInventoryViewFinder::draw()
 	LLFloater::draw();
 }
 
-void  LLInventoryViewFinder::onClose(bool app_quitting)
+void  LLFloaterInventoryFinder::onClose(bool app_quitting)
 {
 	if (mInventoryView) mInventoryView->getControl("Inventory.ShowFilters")->setValue(FALSE);
 	// If you want to reset the filter on close, do it here.  This functionality was
@@ -1268,26 +1271,26 @@ void  LLInventoryViewFinder::onClose(bool app_quitting)
 }
 
 
-BOOL LLInventoryViewFinder::getCheckShowEmpty()
+BOOL LLFloaterInventoryFinder::getCheckShowEmpty()
 {
 	return childGetValue("check_show_empty");
 }
 
-BOOL LLInventoryViewFinder::getCheckSinceLogoff()
+BOOL LLFloaterInventoryFinder::getCheckSinceLogoff()
 {
 	return childGetValue("check_since_logoff");
 }
 
-void LLInventoryViewFinder::onCloseBtn(void* user_data)
+void LLFloaterInventoryFinder::onCloseBtn(void* user_data)
 {
-	LLInventoryViewFinder* finderp = (LLInventoryViewFinder*)user_data;
+	LLFloaterInventoryFinder* finderp = (LLFloaterInventoryFinder*)user_data;
 	finderp->close();
 }
 
 // static
-void LLInventoryViewFinder::selectAllTypes(void* user_data)
+void LLFloaterInventoryFinder::selectAllTypes(void* user_data)
 {
-	LLInventoryViewFinder* self = (LLInventoryViewFinder*)user_data;
+	LLFloaterInventoryFinder* self = (LLFloaterInventoryFinder*)user_data;
 	if(!self) return;
 
 	self->childSetValue("check_animation", TRUE);
@@ -1316,9 +1319,9 @@ void LLInventoryViewFinder::selectAllTypes(void* user_data)
 }
 
 //static
-void LLInventoryViewFinder::selectNoTypes(void* user_data)
+void LLFloaterInventoryFinder::selectNoTypes(void* user_data)
 {
-	LLInventoryViewFinder* self = (LLInventoryViewFinder*)user_data;
+	LLFloaterInventoryFinder* self = (LLFloaterInventoryFinder*)user_data;
 	if(!self) return;
 
 	/*

indra/newview/llpanelmaininventory.h

@@ -33,7 +33,6 @@
 
 #include "llfolderview.h"
 
-class LLInventoryViewFinder;
 class LLFolderViewItem;
 class LLInventoryPanel;
 class LLSaveFolderState;
@@ -48,7 +47,7 @@ class LLComboBox;
 
 class LLInventoryView : public LLFloater, LLInventoryObserver
 {
-friend class LLInventoryViewFinder;
+friend class LLFloaterInventoryFinder;
 
 public:
 	LLInventoryView(const std::string& name, const std::string& rect,
@@ -157,7 +156,7 @@ protected:
 	void init(LLInventoryModel* inventory);
 
 protected:
-	LLInventoryViewFinder* getFinder();
+	LLFloaterInventoryFinder* getFinder();
 	LLSearchEditor*				mSearchEditor;
 	LLComboBox*					mQuickFilterCombo;
 	LLTabContainer*				mFilterTabs;

indra/newview/llviewerdisplay.cpp

@@ -1063,7 +1063,8 @@ void render_hud_attachments()
 		hud_cam.setAxes(LLVector3(1,0,0), LLVector3(0,1,0), LLVector3(0,0,1));
 		LLViewerCamera::updateFrustumPlanes(hud_cam, TRUE);
 
-		bool render_particles = gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES) && gSavedSettings.getBOOL("RenderHUDParticles");
+		static const LLCachedControl<bool> render_hud_particles("RenderHUDParticles");
+		bool render_particles = gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES) && render_hud_particles;
 		
 		//only render hud objects
 		gPipeline.pushRenderTypeMask();
@@ -1407,7 +1408,8 @@ void render_ui_3d()
 	}
 
 	// Coordinate axes
-	if (gSavedSettings.getBOOL("ShowAxes"))
+	static const LLCachedControl<bool> show_axes("ShowAxes");
+	if (show_axes)
 	{
 		draw_axes();
 	}

indra/newview/llviewerjointmesh.cpp

@@ -568,7 +568,8 @@ U32 LLViewerJointMesh::drawShape( F32 pixelArea, BOOL first_pass, BOOL is_dummy)
 		{
 			// This warning will always trigger if you've hacked the avatar to show as incomplete.
 			// Ignore the warning if that's the case.
-			if (!gSavedSettings.getBOOL("RenderUnloadedAvatar"))
+			static const LLCachedControl<bool> rener_unloaded_avatar("RenderUnloadedAvatar");
+			if (!rener_unloaded_avatar)
 			{
 				llwarns << "Layerset without composite" << llendl;
 			}

indra/newview/llviewermenu.cpp

@@ -947,14 +947,14 @@ void init_client_menu(LLMenuGL* menu)
 										&get_visibility,
 										(void*)gDebugView->mFastTimerView,
 										  '9', MASK_CONTROL|MASK_SHIFT ) );
-#if MEM_TRACK_MEM
+//#if MEM_TRACK_MEM
 		sub->append(new LLMenuItemCheckGL("Memory", 
 										&toggle_visibility,
 										NULL,
 										&get_visibility,
 										(void*)gDebugView->mMemoryView,
 										  '0', MASK_CONTROL|MASK_SHIFT ) );
-#endif
+//#endif
 		
 		sub->appendSeparator();
 		

indra/newview/llviewertexture.cpp

@@ -2126,7 +2126,7 @@ bool LLViewerFetchedTexture::updateFetch()
 			c = mComponents;
 		}
 
-		const U32 override_tex_discard_level = gSavedSettings.getU32("TextureDiscardLevel");
+		static const LLCachedControl<U32> override_tex_discard_level("TextureDiscardLevel");
 		if (override_tex_discard_level != 0)
 		{
 			desired_discard = override_tex_discard_level;

indra/newview/llvoavatar.cpp

@@ -3258,29 +3258,6 @@ void LLVOAvatar::getClientInfo(std::string& client, LLColor4& color, BOOL useCom
 		 return;
 	std::string uuid_str = getTE(TEX_HEAD_BODYPAINT)->getID().asString(); //UUID of the head texture
 
-	if(isFullyLoaded())
-	{
-		//Zwagoth's new client identification - HgB
-		// Overwrite the current tag/color settings if new method
-		// exists -- charbl.
-		const LLTextureEntry* texentry = getTE(0);
-		if(texentry->getGlow() > 0.0)
-		{
-			///llinfos << "Using new client identifier." << llendl;
-			U8 tag_buffer[UUID_BYTES+1];
-			memset(&tag_buffer, 0, UUID_BYTES);
-			memcpy(&tag_buffer[0], &texentry->getID().mData, UUID_BYTES);
-			tag_buffer[UUID_BYTES] = 0;
-			U32 tag_len = strlen((const char*)&tag_buffer[0]);
-			tag_len = (tag_len>UUID_BYTES) ? (UUID_BYTES) : tag_len;
-			client = std::string((char*)&tag_buffer[0], tag_len);
-			LLStringFn::replace_ascii_controlchars(mClientTag, LL_UNKNOWN_CHAR);
-			mNameString.clear();
-			color = texentry->getColor();
-			return;
-		}
-	}
-
 	static const LLCachedControl<LLColor4>	avatar_name_color(gColors,"AvatarNameColor",LLColor4(LLColor4U(251, 175, 93, 255)) );
 	if (isSelf())
 	{
@@ -3574,24 +3551,48 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
 					new_name = TRUE;
 				}
 				
-				LLColor4 avatar_name_color = gColors.getColor( "AvatarNameColor" );
+				static const LLCachedControl<LLColor4> avatar_name_color(gColors, "AvatarNameColor" );
-
 
 				//As pointed out by Zwagoth, we really shouldn't be doing this per-frame. Skip if we already have the data. -HgB
 				if (mClientTag == "")
 				{
-					mClientColor = gColors.getColor( "AvatarNameColor" );
+					mClientColor = avatar_name_color;
-					getClientInfo(mClientTag,mClientColor);
+					if(isFullyLoaded())
-					if(mClientTag == "")
 					{
-							client = "?"; //prevent console spam..
+						//Zwagoth's new client identification - HgB
+						// Overwrite the current tag/color settings if new method
+						// exists -- charbl.
+						const LLTextureEntry* texentry = getTE(0);
+						if(texentry->getGlow() > 0.0)
+						{
+							llinfos << "Using new client identifier." << llendl;
+							U8 tag_buffer[UUID_BYTES+1];
+							memset(&tag_buffer, 0, UUID_BYTES);
+							memcpy(&tag_buffer[0], &texentry->getID().mData, UUID_BYTES);
+							tag_buffer[UUID_BYTES] = 0;
+							U32 tag_len = strlen((const char*)&tag_buffer[0]);
+							tag_len = (tag_len>UUID_BYTES) ? (UUID_BYTES) : tag_len;
+							mClientTag = std::string((char*)&tag_buffer[0], tag_len);
+							LLStringFn::replace_ascii_controlchars(mClientTag, LL_UNKNOWN_CHAR);
+							mNameString.clear();
+							mClientColor = texentry->getColor();
+						}
+						else
+						{
+							//llinfos << "Using Emerald-style client identifier." << llendl;
+							//The old client identification. Used only if the new method doesn't exist, so that it isn't automatically overwritten. -HgB
+							getClientInfo(mClientTag,mClientColor);
+							if(mClientTag == "")
+								client = "?"; //prevent console spam..
+						}	
 					}
 
 					// Overwrite the tag/color shit yet again if we want to see
 					// friends in a special color. -- charbl
 					if (LLAvatarTracker::instance().getBuddyInfo(this->getID()) != NULL)
 					{
-						if (gSavedSettings.getBOOL("AscentShowFriendsTag"))
+						static const LLCachedControl<bool> ascent_show_friends_tag("AscentShowFriendsTag");
+						if (ascent_show_friends_tag)
 						{
 							mClientTag = "Friend";
 						}
@@ -3611,33 +3612,41 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
 					//Lindens are always more Linden than your friend, make that take precedence
 					if(LLMuteList::getInstance()->isLinden(getFullname()))
 					{
-						mClientColor = gSavedSettings.getColor4("AscentLindenColor");
+						static const LLCachedControl<LLColor4> ascent_linden_color(gColors, "AscentLindenColor" );
+						mClientColor = ascent_linden_color;
 					}
 					//check if they are an estate owner at their current position
 					else if(estate_owner.notNull() && this->getID() == estate_owner)
 					{
-						mClientColor = gSavedSettings.getColor4("AscentEstateOwnerColor");
+						static const LLCachedControl<LLColor4> ascent_estate_owner_color(gColors, "AscentEstateOwnerColor" );
+						mClientColor = ascent_estate_owner_color;
 					}
 					//without these dots, SL would suck.
 					else if (LLAvatarTracker::instance().getBuddyInfo(this->getID()) != NULL)
 					{
-						mClientColor = gSavedSettings.getColor4("AscentFriendColor");
+						static const LLCachedControl<LLColor4> ascent_friend_color(gColors, "AscentFriendColor" );
+						mClientColor = ascent_friend_color;
 					}
 					//big fat jerkface who is probably a jerk, display them as such.
 					else if(LLMuteList::getInstance()->isMuted(this->getID()))
 					{
-						mClientColor = gSavedSettings.getColor4("AscentMutedColor");
+						static const LLCachedControl<LLColor4> ascent_muted_color(gColors, "AscentMutedColor" );
+						mClientColor = ascent_muted_color;
 					}
 				}
 
 				client = mClientTag;
-				if ((isSelf() && gSavedSettings.getBOOL("AscentShowSelfTagColor"))
+
-							|| (!isSelf() && gSavedSettings.getBOOL("AscentShowOthersTagColor")))
+				static const LLCachedControl<bool> ascent_show_self_tag_color("AscentShowSelfTagColor");
-					avatar_name_color = mClientColor;
+				static const LLCachedControl<bool> ascent_show_others_tag_color("AscentShowOthersTagColor");
+				LLColor4 name_color = avatar_name_color;
+				if ((isSelf() && ascent_show_self_tag_color)
+							|| (!isSelf() && ascent_show_others_tag_color))
+					name_color = mClientColor;
 
 
-				avatar_name_color.setAlpha(alpha);
+				name_color.setAlpha(alpha);
-				mNameText->setColor(avatar_name_color);
+				mNameText->setColor(name_color);
 				
 				LLQuaternion root_rot = mRoot.getWorldRotation();
 				//mNameText->setUsePixelSize(TRUE);
@@ -3719,7 +3728,8 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
 			}
 			//idle text
 			std::string idle_string;
-			if(!isSelf() && mIdleTimer.getElapsedTimeF32() > 120.f && gSavedSettings.getBOOL("AscentShowIdleTime"))
+			static LLCachedControl<bool> ascent_show_idle_time("AscentShowIdleTime");
+			if(!isSelf() && mIdleTimer.getElapsedTimeF32() > 120.f && ascent_show_idle_time)
 			{
 				idle_string = getIdleTime();
 			}
@@ -4049,6 +4059,7 @@ void LLVOAvatar::slamPosition()
 
 bool LLVOAvatar::isVisuallyMuted()
 {
+	if(isSelf())return false;
 	static LLCachedControl<U32> max_attachment_bytes(gSavedSettings, "RenderAutoMuteByteLimit");
 	static LLCachedControl<F32> max_attachment_area(gSavedSettings, "RenderAutoMuteSurfaceAreaLimit");
 	
@@ -4907,8 +4918,8 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
 
 	if (pass == AVATAR_RENDER_PASS_SINGLE)
 	{
-
+		bool is_muted = isVisuallyMuted();	//Disable masking and also disable alpha in LLViewerJoint::render
-		const bool should_alpha_mask = shouldAlphaMask();
+		const bool should_alpha_mask = !is_muted && shouldAlphaMask();
 		LLGLState test(GL_ALPHA_TEST, should_alpha_mask);
 		
 		if (should_alpha_mask && !LLGLSLShader::sNoFixedFunction)
@@ -4923,19 +4934,19 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
 			{
 				if (isTextureVisible(TEX_HEAD_BAKED) || mIsDummy)
 				{
-					num_indices += mMeshLOD[MESH_ID_HEAD]->render(mAdjustedPixelArea, TRUE, mIsDummy);
+					num_indices += mMeshLOD[MESH_ID_HEAD]->render(mAdjustedPixelArea, TRUE, mIsDummy || is_muted);
 					first_pass = FALSE;
 				}
 			}
 			if (isTextureVisible(TEX_UPPER_BAKED) || mIsDummy)
 			{
-				num_indices += mMeshLOD[MESH_ID_UPPER_BODY]->render(mAdjustedPixelArea, first_pass, mIsDummy);
+				num_indices += mMeshLOD[MESH_ID_UPPER_BODY]->render(mAdjustedPixelArea, first_pass, mIsDummy || is_muted);
 				first_pass = FALSE;
 			}
 			
 			if (isTextureVisible(TEX_LOWER_BAKED) || mIsDummy)
 			{
-				num_indices += mMeshLOD[MESH_ID_LOWER_BODY]->render(mAdjustedPixelArea, first_pass, mIsDummy);
+				num_indices += mMeshLOD[MESH_ID_LOWER_BODY]->render(mAdjustedPixelArea, first_pass, mIsDummy || is_muted);
 				first_pass = FALSE;
 			}
 		}
@@ -7912,7 +7923,8 @@ BOOL LLVOAvatar::isFullyLoaded() const
 {
 // [SL:KB] - Patch: Appearance-SyncAttach | Checked: 2010-09-22 (Catznip-2.2.0a) | Added: Catznip-2.2.0a
 	// Changes to LLAppearanceMgr::updateAppearanceFromCOF() expect this function to actually return mFullyLoaded for gAgentAvatarp
-	if ( (!isSelf()) && (gSavedSettings.getBOOL("RenderUnloadedAvatar")) )
+	static const LLCachedControl<bool> rener_unloaded_avatar("RenderUnloadedAvatar");
+	if ( (!isSelf()) && (rener_unloaded_avatar) )
 		return TRUE;
 	else
 		return mFullyLoaded;

indra/newview/llvovolume.cpp

@@ -821,7 +821,7 @@ BOOL LLVOVolume::setVolume(const LLVolumeParams &params_in, const S32 detail, bo
 	
 	if (is404)
 	{
-		setIcon(LLViewerTextureManager::getFetchedTextureFromFile("icons/Inv_Mesh.png", TRUE, LLViewerTexture::BOOST_UI));
+		setIcon(LLViewerTextureManager::getFetchedTextureFromFile("inv_item_mesh.tga", TRUE, LLViewerTexture::BOOST_UI));
 		//render prim proxy when mesh loading attempts give up
 		volume_params.setSculptID(LLUUID::null, LL_SCULPT_TYPE_NONE);
 

indra/newview/pipeline.cpp

@@ -388,7 +388,7 @@ LLPipeline::LLPipeline() :
 
 void LLPipeline::init()
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_INIT);
 
 	refreshCachedSettings();
 
@@ -868,6 +868,7 @@ void LLPipeline::releaseScreenBuffers()
 void LLPipeline::createGLBuffers()
 {
 	stop_glerror();
+	LLMemType mt_cb(LLMemType::MTYPE_PIPELINE_CREATE_BUFFERS);
 	assertInitialized();
 
 	updateRenderDeferred();
@@ -954,7 +955,8 @@ void LLPipeline::createGLBuffers()
 
 					//F32 sp = acosf(sa)/(1.f-spec);
 
-					sa = powf(sa, gSavedSettings.getF32("RenderSpecularExponent"));
+					static const LLCachedControl<F32> render_specular_exponent("RenderSpecularExponent");
+					sa = powf(sa, render_specular_exponent);
 					F32 a = acosf(sa*0.25f+0.75f);
 					F32 m = llmax(0.5f-spec*0.5f, 0.001f);
 					F32 t2 = tanf(a)/m;
@@ -982,6 +984,7 @@ void LLPipeline::createGLBuffers()
 
 void LLPipeline::restoreGL() 
 {
+	LLMemType mt_cb(LLMemType::MTYPE_PIPELINE_RESTORE_GL);
 	assertInitialized();
 
 	if (mVertexShadersEnabled)
@@ -1043,6 +1046,7 @@ BOOL LLPipeline::canUseAntiAliasing() const
 
 void LLPipeline::unloadShaders()
 {
+	LLMemType mt_us(LLMemType::MTYPE_PIPELINE_UNLOAD_SHADERS);
 	LLViewerShaderMgr::instance()->unloadShaders();
 
 	mVertexShadersLoaded = 0;
@@ -1074,6 +1078,7 @@ S32 LLPipeline::getMaxLightingDetail() const
 
 S32 LLPipeline::setLightingDetail(S32 level)
 {
+	LLMemType mt_ld(LLMemType::MTYPE_PIPELINE_LIGHTING_DETAIL);
 	refreshCachedSettings();
 
 	if (level < 0)
@@ -1264,7 +1269,7 @@ LLDrawPool* LLPipeline::getPoolFromTE(const LLTextureEntry* te, LLViewerTexture*
 //static 
 U32 LLPipeline::getPoolTypeFromTE(const LLTextureEntry* te, LLViewerTexture* imagep)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt_gpt(LLMemType::MTYPE_PIPELINE_GET_POOL_TYPE);
 	
 	if (!te || !imagep)
 	{
@@ -1294,7 +1299,7 @@ U32 LLPipeline::getPoolTypeFromTE(const LLTextureEntry* te, LLViewerTexture* ima
 
 void LLPipeline::addPool(LLDrawPool *new_poolp)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt_a(LLMemType::MTYPE_PIPELINE_ADD_POOL);
 	assertInitialized();
 	mPools.insert(new_poolp);
 	addToQuickLookup( new_poolp );
@@ -1306,7 +1311,7 @@ void LLPipeline::allocDrawable(LLViewerObject *vobj)
 	{
 		llerrs << "Null object passed to allocDrawable!" << llendl;
 	}
-	LLMemType mt(LLMemType::MTYPE_DRAWABLE);
+	LLMemType mt_ad(LLMemType::MTYPE_PIPELINE_ALLOCATE_DRAWABLE);
 	LLDrawable *drawable = new LLDrawable();
 	vobj->mDrawable = drawable;
 	
@@ -1399,7 +1404,7 @@ U32 LLPipeline::addObject(LLViewerObject *vobj)
 	{
 		return 0;
 	}
-
+	LLMemType mt_ao(LLMemType::MTYPE_PIPELINE_ADD_OBJECT);
 	static const LLCachedControl<bool> render_delay_creation("RenderDelayCreation",false);
 	if (!vobj->isAvatar() && render_delay_creation)
 	{
@@ -1416,7 +1421,7 @@ U32 LLPipeline::addObject(LLViewerObject *vobj)
 void LLPipeline::createObjects(F32 max_dtime)
 {
 	LLFastTimer ftm(FTM_GEO_UPDATE);
-	LLMemType mt(LLMemType::MTYPE_DRAWABLE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_CREATE_OBJECTS);
 
 	LLTimer update_timer;
 
@@ -1591,7 +1596,7 @@ static LLFastTimer::DeclareTimer FTM_UPDATE_MOVE("Update Move");
 void LLPipeline::updateMove()
 {
 	LLFastTimer t(FTM_UPDATE_MOVE);
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt_um(LLMemType::MTYPE_PIPELINE_UPDATE_MOVE);
 
 	static const LLCachedControl<bool> freeze_time("FreezeTime",false);
 	if (freeze_time)
@@ -1945,7 +1950,7 @@ static LLFastTimer::DeclareTimer FTM_CULL("Object Culling");
 void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result, S32 water_clip, LLPlane* planep)
 {
 	LLFastTimer t(FTM_CULL);
-	LLMemType mt_uc(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt_uc(LLMemType::MTYPE_PIPELINE_UPDATE_CULL);
 
 	grabReferences(result);
 
@@ -2314,7 +2319,7 @@ void LLPipeline::rebuildGroups()
 void LLPipeline::updateGeom(F32 max_dtime)
 {
 	LLTimer update_timer;
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_UPDATE_GEOM);
 	LLPointer<LLDrawable> drawablep;
 
 	LLFastTimer t(FTM_GEO_UPDATE);
@@ -2417,7 +2422,7 @@ void LLPipeline::updateGeom(F32 max_dtime)
 
 void LLPipeline::markVisible(LLDrawable *drawablep, LLCamera& camera)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_MARK_VISIBLE);
 
 	if(drawablep && !drawablep->isDead())
 	{
@@ -2462,7 +2467,7 @@ void LLPipeline::markVisible(LLDrawable *drawablep, LLCamera& camera)
 
 void LLPipeline::markMoved(LLDrawable *drawablep, BOOL damped_motion)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt_mm(LLMemType::MTYPE_PIPELINE_MARK_MOVED);
 
 	if (!drawablep)
 	{
@@ -2508,7 +2513,7 @@ void LLPipeline::markMoved(LLDrawable *drawablep, BOOL damped_motion)
 
 void LLPipeline::markShift(LLDrawable *drawablep)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_MARK_SHIFT);
 
 	if (!drawablep || drawablep->isDead())
 	{
@@ -2531,7 +2536,7 @@ void LLPipeline::markShift(LLDrawable *drawablep)
 
 void LLPipeline::shiftObjects(const LLVector3 &offset)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_SHIFT_OBJECTS);
 
 	assertInitialized();
 
@@ -2575,7 +2580,7 @@ void LLPipeline::shiftObjects(const LLVector3 &offset)
 
 void LLPipeline::markTextured(LLDrawable *drawablep)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_MARK_TEXTURED);
 
 	if (drawablep && !drawablep->isDead() && assertInitialized())
 	{
@@ -2666,7 +2671,7 @@ void LLPipeline::markRebuild(LLSpatialGroup* group, BOOL priority)
 
 void LLPipeline::markRebuild(LLDrawable *drawablep, LLDrawable::EDrawableFlags flag, BOOL priority)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_MARK_REBUILD);
 
 	if (drawablep && !drawablep->isDead() && assertInitialized())
 	{
@@ -2714,7 +2719,7 @@ void LLPipeline::stateSort(LLCamera& camera, LLCullResult &result)
 	}
 
 	LLFastTimer ftm(FTM_STATESORT);
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_STATE_SORT);
 
 	//LLVertexBuffer::unbind();
 
@@ -2815,7 +2820,7 @@ void LLPipeline::stateSort(LLCamera& camera, LLCullResult &result)
 
 void LLPipeline::stateSort(LLSpatialGroup* group, LLCamera& camera)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_STATE_SORT);
 	if (!sSkipUpdate && group->changeLOD())
 	{
 		for (LLSpatialGroup::element_iter i = group->getData().begin(); i != group->getData().end(); ++i)
@@ -2834,7 +2839,7 @@ void LLPipeline::stateSort(LLSpatialGroup* group, LLCamera& camera)
 
 void LLPipeline::stateSort(LLSpatialBridge* bridge, LLCamera& camera)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_STATE_SORT);
 	if (/*!sShadowRender && */!sSkipUpdate && bridge->getSpatialGroup()->changeLOD())
 	{
 		bool force_update = false;
@@ -2844,7 +2849,7 @@ void LLPipeline::stateSort(LLSpatialBridge* bridge, LLCamera& camera)
 
 void LLPipeline::stateSort(LLDrawable* drawablep, LLCamera& camera)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_STATE_SORT);
 		
 	if (!drawablep
 		|| drawablep->isDead() 
@@ -3093,7 +3098,7 @@ void renderSoundHighlights(LLDrawable* drawablep)
 
 void LLPipeline::postSort(LLCamera& camera)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_POST_SORT);
 	LLFastTimer ftm(FTM_STATESORT_POSTSORT);
 
 	assertInitialized();
@@ -3333,6 +3338,7 @@ void LLPipeline::postSort(LLCamera& camera)
 
 void render_hud_elements()
 {
+	LLMemType mt_rhe(LLMemType::MTYPE_PIPELINE_RENDER_HUD_ELS);
 	LLFastTimer t(FTM_RENDER_UI);
 	gPipeline.disableLights();		
 
@@ -3352,25 +3358,22 @@ void render_hud_elements()
 	}
 	LLGLDepthTest depth(GL_TRUE, GL_FALSE);
 
-	if (gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI))
+	if (!LLPipeline::sReflectionRender && gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI))
 	{
-		if(!LLPipeline::sReflectionRender)
+		static const LLCachedControl<U32> RenderFSAASamples("RenderFSAASamples",0);
-		{
+		LLGLEnable multisample(RenderFSAASamples > 0 ? GL_MULTISAMPLE_ARB : 0);
-			static const LLCachedControl<U32> RenderFSAASamples("RenderFSAASamples",0);
+		gViewerWindow->renderSelections(FALSE, FALSE, FALSE); // For HUD version in render_ui_3d()
-			LLGLEnable multisample(RenderFSAASamples > 0 ? GL_MULTISAMPLE_ARB : 0);
-			gViewerWindow->renderSelections(FALSE, FALSE, FALSE); // For HUD version in render_ui_3d()
 	
-			// Draw the tracking overlays
+		// Draw the tracking overlays
-			LLTracker::render3D();
+		LLTracker::render3D();
 		
-			// Show the property lines
+		// Show the property lines
-			LLWorld::getInstance()->renderPropertyLines();
+		LLWorld::getInstance()->renderPropertyLines();
-			LLViewerParcelMgr::getInstance()->render();
+		LLViewerParcelMgr::getInstance()->render();
-			LLViewerParcelMgr::getInstance()->renderParcelCollision();
+		LLViewerParcelMgr::getInstance()->renderParcelCollision();
 	
-			// Render name tags.
+		// Render name tags.
-			LLHUDObject::renderAll();
+		LLHUDObject::renderAll();
-		}
 	}
 	else if (gForceRenderLandFence)
 	{
@@ -3391,7 +3394,7 @@ void render_hud_elements()
 
 void LLPipeline::renderHighlights()
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_RENDER_HL);
 
 	assertInitialized();
 
@@ -3456,9 +3459,10 @@ void LLPipeline::renderHighlights()
 
 //debug use
 U32 LLPipeline::sCurRenderPoolType = 0 ;
+
 void LLPipeline::renderGeom(LLCamera& camera, BOOL forceVBOUpdate)
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_RENDER_GEOM);
 	LLFastTimer t(FTM_RENDER_GEOMETRY);
 
 	assertInitialized();
@@ -3723,6 +3727,7 @@ void LLPipeline::renderGeom(LLCamera& camera, BOOL forceVBOUpdate)
 void LLPipeline::renderGeomDeferred(LLCamera& camera)
 {
 	LLAppViewer::instance()->pingMainloopTimeout("Pipeline:RenderGeomDeferred");
+	LLMemType mt_rgd(LLMemType::MTYPE_PIPELINE_RENDER_GEOM_DEFFERRED);
 	LLFastTimer t(FTM_RENDER_GEOMETRY);
 
 	LLFastTimer t2(FTM_POOLS);
@@ -3822,6 +3827,7 @@ void LLPipeline::renderGeomDeferred(LLCamera& camera)
 
 void LLPipeline::renderGeomPostDeferred(LLCamera& camera)
 {
+	LLMemType mt_rgpd(LLMemType::MTYPE_PIPELINE_RENDER_GEOM_POST_DEF);
 	LLFastTimer t(FTM_POOLS);
 	U32 cur_type = 0;
 
@@ -3918,6 +3924,7 @@ void LLPipeline::renderGeomPostDeferred(LLCamera& camera)
 
 void LLPipeline::renderGeomShadow(LLCamera& camera)
 {
+	LLMemType mt_rgs(LLMemType::MTYPE_PIPELINE_RENDER_GEOM_SHADOW);
 	U32 cur_type = 0;
 	
 	LLGLEnable cull(GL_CULL_FACE);
@@ -4351,7 +4358,7 @@ void LLPipeline::renderDebug()
 
 void LLPipeline::rebuildPools()
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_REBUILD_POOLS);
 
 	assertInitialized();
 
@@ -4391,7 +4398,7 @@ void LLPipeline::rebuildPools()
 
 void LLPipeline::addToQuickLookup( LLDrawPool* new_poolp )
 {
-	LLMemType mt(LLMemType::MTYPE_PIPELINE);
+	LLMemType mt(LLMemType::MTYPE_PIPELINE_QUICK_LOOKUP);
 
 	assertInitialized();
 
@@ -6000,6 +6007,7 @@ void LLPipeline::doResetVertexBuffers()
 
 void LLPipeline::renderObjects(U32 type, U32 mask, BOOL texture, BOOL batch_texture)
 {
+	LLMemType mt_ro(LLMemType::MTYPE_PIPELINE_RENDER_OBJECTS);
 	assertInitialized();
 	gGL.loadMatrix(gGLModelView);
 	gGLLastMatrix = NULL;
@@ -6075,6 +6083,7 @@ void LLPipeline::bindScreenToTexture()
 static LLFastTimer::DeclareTimer FTM_RENDER_BLOOM("Bloom");
 void LLPipeline::renderBloom(BOOL for_snapshot, F32 zoom_factor, int subfield, bool tiling)
 {
+	LLMemType mt_ru(LLMemType::MTYPE_PIPELINE_RENDER_BLOOM);
 	if (!(gPipeline.canUseVertexShaders() &&
 		sRenderGlow))
 	{
@@ -9201,6 +9210,7 @@ void LLPipeline::renderGroups(LLRenderPass* pass, U32 type, U32 mask, BOOL textu
 
 void LLPipeline::generateImpostor(LLVOAvatar* avatar)
 {
+	LLMemType mt_gi(LLMemType::MTYPE_PIPELINE_GENERATE_IMPOSTOR);
 	LLGLState::checkStates();
 	LLGLState::checkTextureChannels();
 	LLGLState::checkClientArrays();

indra/newview/skins/Pony-Aquablue/textures/textures.xml

@@ -130,6 +130,9 @@
   <texture name="inv_item_object.tga"/>
   <texture name="inv_item_object_multi.tga"/>
   <texture name="inv_item_pants.tga"/>
+  <texture name="inv_item_mesh.tga"/>
+  <texture name="inv_item_physics.tga"/>
+  <texture name="inv_item_tattoo.tga"/>
   <texture name="inv_item_script.tga"/>
   <texture name="inv_item_shape.tga"/>
   <texture name="inv_item_shirt.tga"/>

indra/newview/skins/Pony-Purple/textures/textures.xml

@@ -130,6 +130,9 @@
   <texture name="inv_item_object.tga"/>
   <texture name="inv_item_object_multi.tga"/>
   <texture name="inv_item_pants.tga"/>
+  <texture name="inv_item_mesh.tga"/>
+  <texture name="inv_item_physics.tga"/>
+  <texture name="inv_item_tattoo.tga"/>
   <texture name="inv_item_script.tga"/>
   <texture name="inv_item_shape.tga"/>
   <texture name="inv_item_shirt.tga"/>

indra/newview/skins/dark/textures/textures.xml

@@ -154,6 +154,9 @@
   <inv_item_object.tga/>
   <inv_item_object_multi.tga/>
   <inv_item_pants.tga/>
+  <inv_item_mesh.tga/>
+  <inv_item_physics.tga/>
+  <inv_item_tattoo.tga/>
   <inv_item_script.tga/>
   <inv_item_shape.tga/>
   <inv_item_shirt.tga/>

indra/newview/skins/darkgred/textures/textures.xml

@@ -154,6 +154,9 @@
   <inv_item_object.tga/>
   <inv_item_object_multi.tga/>
   <inv_item_pants.tga/>
+  <inv_item_mesh.tga/>
+  <inv_item_physics.tga/>
+  <inv_item_tattoo.tga/>
   <inv_item_script.tga/>
   <inv_item_shape.tga/>
   <inv_item_shirt.tga/>

indra/newview/skins/darkorange/textures/textures.xml

@@ -130,6 +130,9 @@
   <texture name="inv_item_object.tga"/>
   <texture name="inv_item_object_multi.tga"/>
   <texture name="inv_item_pants.tga"/>
+  <texture name="inv_item_mesh.tga"/>
+  <texture name="inv_item_physics.tga"/>
+  <texture name="inv_item_tattoo.tga"/>
   <texture name="inv_item_script.tga"/>
   <texture name="inv_item_shape.tga"/>
   <texture name="inv_item_shirt.tga"/>

indra/newview/skins/default/textures/textures.xml

@@ -133,6 +133,9 @@
   <texture name="inv_item_object.tga"/>
   <texture name="inv_item_object_multi.tga"/>
   <texture name="inv_item_pants.tga"/>
+  <texture name="inv_item_mesh.tga"/>
+  <texture name="inv_item_physics.tga"/>
+  <texture name="inv_item_tattoo.tga"/>
   <texture name="inv_item_script.tga"/>
   <texture name="inv_item_shape.tga"/>
   <texture name="inv_item_shirt.tga"/>

indra/newview/skins/emerald/textures/textures.xml

@@ -130,6 +130,9 @@
   <texture name="inv_item_object.tga"/>
   <texture name="inv_item_object_multi.tga"/>
   <texture name="inv_item_pants.tga"/>
+  <texture name="inv_item_mesh.tga"/>
+  <texture name="inv_item_physics.tga"/>
+  <texture name="inv_item_tattoo.tga"/>
   <texture name="inv_item_script.tga"/>
   <texture name="inv_item_shape.tga"/>
   <texture name="inv_item_shirt.tga"/>

indra/newview/skins/gemini/textures/textures.xml

@@ -130,6 +130,9 @@
   <texture name="inv_item_object.tga"/>
   <texture name="inv_item_object_multi.tga"/>
   <texture name="inv_item_pants.tga"/>
+  <texture name="inv_item_mesh.tga"/>
+  <texture name="inv_item_physics.tga"/>
+  <texture name="inv_item_tattoo.tga"/>
   <texture name="inv_item_script.tga"/>
   <texture name="inv_item_shape.tga"/>
   <texture name="inv_item_shirt.tga"/>

indra/newview/skins/gred/textures/textures.xml

@@ -154,6 +154,9 @@
   <inv_item_object.tga/>
   <inv_item_object_multi.tga/>
   <inv_item_pants.tga/>
+  <inv_item_mesh.tga/>
+  <inv_item_physics.tga/>
+  <inv_item_tattoo.tga/>
   <inv_item_script.tga/>
   <inv_item_shape.tga/>
   <inv_item_shirt.tga/>

indra/newview/skins/kdarknv/textures/textures.xml

@@ -130,6 +130,9 @@
   <texture name="inv_item_object.tga"/>
   <texture name="inv_item_object_multi.tga"/>
   <texture name="inv_item_pants.tga"/>
+  <texture name="inv_item_mesh.tga"/>
+  <texture name="inv_item_physics.tga"/>
+  <texture name="inv_item_tattoo.tga"/>
   <texture name="inv_item_script.tga"/>
   <texture name="inv_item_shape.tga"/>
   <texture name="inv_item_shirt.tga"/>

indra/newview/skins/kliteat/textures/textures.xml

@@ -134,6 +134,9 @@
   <texture name="inv_item_object.tga"/>
   <texture name="inv_item_object_multi.tga"/>
   <texture name="inv_item_pants.tga"/>
+  <texture name="inv_item_mesh.tga"/>
+  <texture name="inv_item_physics.tga"/>
+  <texture name="inv_item_tattoo.tga"/>
   <texture name="inv_item_script.tga"/>
   <texture name="inv_item_shape.tga"/>
   <texture name="inv_item_shirt.tga"/>

indra/newview/skins/openlife/textures/textures.xml

@@ -134,6 +134,9 @@
   <texture name="inv_item_object.tga"/>
   <texture name="inv_item_object_multi.tga"/>
   <texture name="inv_item_pants.tga"/>
+  <texture name="inv_item_mesh.tga"/>
+  <texture name="inv_item_physics.tga"/>
+  <texture name="inv_item_tattoo.tga"/>
   <texture name="inv_item_script.tga"/>
   <texture name="inv_item_shape.tga"/>
   <texture name="inv_item_shirt.tga"/>

indra/newview/skins/pslgreen/textures/textures.xml

@@ -154,6 +154,9 @@
   <inv_item_object.tga/>
   <inv_item_object_multi.tga/>
   <inv_item_pants.tga/>
+  <inv_item_mesh.tga/>
+  <inv_item_physics.tga/>
+  <inv_item_tattoo.tga/>
   <inv_item_script.tga/>
   <inv_item_shape.tga/>
   <inv_item_shirt.tga/>

indra/newview/skins/pslpurple/textures/textures.xml

@@ -154,6 +154,9 @@
   <inv_item_object.tga/>
   <inv_item_object_multi.tga/>
   <inv_item_pants.tga/>
+  <inv_item_mesh.tga/>
+  <inv_item_physics.tga/>
+  <inv_item_tattoo.tga/>
   <inv_item_script.tga/>
   <inv_item_shape.tga/>
   <inv_item_shirt.tga/>

indra/newview/skins/wisdom/textures/textures.xml

@@ -130,6 +130,9 @@
   <texture name="inv_item_object.tga"/>
   <texture name="inv_item_object_multi.tga"/>
   <texture name="inv_item_pants.tga"/>
+  <texture name="inv_item_mesh.tga"/>
+  <texture name="inv_item_physics.tga"/>
+  <texture name="inv_item_tattoo.tga"/>
   <texture name="inv_item_script.tga"/>
   <texture name="inv_item_shape.tga"/>
   <texture name="inv_item_shirt.tga"/>