Ported some stats and texture console changes from Snowglobe.

7 files changed, 510 insertions, 57 deletions

diff --git a/linden/indra/llcommon/llfasttimer.h b/linden/indra/llcommon/llfasttimer.h
index 60281fd..8c1cf47 100644
--- a/linden/indra/llcommon/llfasttimer.h
+++ b/linden/indra/llcommon/llfasttimer.h
@@ -161,6 +161,7 @@ public:
                 FTM_IMAGE_UPDATE,
                 FTM_IMAGE_CREATE,
                 FTM_IMAGE_DECODE,
+                FTM_IMAGE_READBACK,
                 FTM_IMAGE_MARK_DIRTY,
                 FTM_PIPELINE,
                 FTM_VFILE_WAIT,
@@ -194,7 +195,7 @@ public:
         enum { FTM_MAX_DEPTH = 64 };
         
 public:
-        static LLFastTimer::EFastTimerType sCurType;
+        static EFastTimerType sCurType;
 
         LLFastTimer(EFastTimerType type)
         {
diff --git a/linden/indra/newview/llappviewer.cpp b/linden/indra/newview/llappviewer.cpp
index a630beb..3a509ff 100644
--- a/linden/indra/newview/llappviewer.cpp
+++ b/linden/indra/newview/llappviewer.cpp
@@ -616,6 +616,9 @@ bool LLAppViewer::init()
         //////////////////////////////////////////////////////////////////////////////
         // *FIX: The following code isn't grouped into functions yet.
 
+        // Statistics / debug timer initialization
+        init_statistics();
+        
         //
         // Various introspection concerning the libs we're using - particularly
         // the libs involved in getting to a full login screen.
diff --git a/linden/indra/newview/llfasttimerview.cpp b/linden/indra/newview/llfasttimerview.cpp
index c9037d0..5e8095e 100644
--- a/linden/indra/newview/llfasttimerview.cpp
+++ b/linden/indra/newview/llfasttimerview.cpp
@@ -147,6 +147,7 @@ static struct ft_display_info ft_display_table[] =
         { LLFastTimer::FTM_IMAGE_UPDATE,                "  Image Update",       &LLColor4::yellow4, 1 },
         { LLFastTimer::FTM_IMAGE_CREATE,                "   Image CreateGL",&LLColor4::yellow5, 0 },
         { LLFastTimer::FTM_IMAGE_DECODE,                "   Image Decode",      &LLColor4::yellow6, 0 },
+        { LLFastTimer::FTM_IMAGE_READBACK,              "   Image Readback",&LLColor4::red2, 0 },
         { LLFastTimer::FTM_IMAGE_MARK_DIRTY,    "   Dirty Textures",&LLColor4::red1, 0 },
         { LLFastTimer::FTM_STATESORT,                   "  State Sort", &LLColor4::orange1, 1 },
         { LLFastTimer::FTM_STATESORT_DRAWABLE,  "   Drawable",          &LLColor4::orange2, 0 },
diff --git a/linden/indra/newview/lltextureview.cpp b/linden/indra/newview/lltextureview.cpp
index b6159da..cda01fa 100644
--- a/linden/indra/newview/lltextureview.cpp
+++ b/linden/indra/newview/lltextureview.cpp
@@ -222,10 +222,10 @@ void LLTextureBar::draw()
                 { "DSK", LLColor4::blue },      // CACHE_POST
                 { "NET", LLColor4::green },     // LOAD_FROM_NETWORK
                 { "SIM", LLColor4::green },     // LOAD_FROM_SIMULATOR
-                { "URL", LLColor4::green2 },// LOAD_FROM_HTTP_GET_URL
-                { "HTP", LLColor4::green },     // LOAD_FROM_HTTP_GET_DATA
+                { "REQ", LLColor4::yellow },// SEND_HTTP_REQ
+                { "HTP", LLColor4::green },     // WAIT_HTTP_REQ
                 { "DEC", LLColor4::yellow },// DECODE_IMAGE
-                { "DEC", LLColor4::yellow },// DECODE_IMAGE_UPDATE
+                { "DEC", LLColor4::green }, // DECODE_IMAGE_UPDATE
                 { "WRT", LLColor4::purple },// WRITE_TO_CACHE
                 { "WRT", LLColor4::orange },// WAIT_ON_WRITE
                 { "END", LLColor4::red },   // DONE
@@ -253,7 +253,7 @@ void LLTextureBar::draw()
 
         // Draw the progress bar.
         S32 bar_width = 100;
-        S32 bar_left = 280;
+        S32 bar_left = 260;
         left = bar_left;
         right = left + bar_width;
 
@@ -278,30 +278,31 @@ void LLTextureBar::draw()
         S32 pip_x = title_x3 + pip_space/2;
         
         // Draw the packet pip
+        const F32 pip_max_time = 5.f;
         F32 last_event = mImagep->mLastPacketTimer.getElapsedTimeF32();
-        if (last_event < 1.f)
+        if (last_event < pip_max_time)
         {
                 clr = LLColor4::white; 
         }
         else
         {
                 last_event = mImagep->mRequestDeltaTime;
-                if (last_event < 1.f)
+                if (last_event < pip_max_time)
                 {
                         clr = LLColor4::green;
                 }
                 else
                 {
                         last_event = mImagep->mFetchDeltaTime;
-                        if (last_event < 1.f)
+                        if (last_event < pip_max_time)
                         {
                                 clr = LLColor4::yellow;
                         }
                 }
         }
-        if (last_event < 1.f)
+        if (last_event < pip_max_time)
         {
-                clr.setAlpha(1.f - last_event);
+                clr.setAlpha(1.f - last_event/pip_max_time);
                 gGL.color4fv(clr.mV);
                 gl_rect_2d(pip_x, top, pip_x + pip_width, bottom);
         }
@@ -391,77 +392,93 @@ void LLGLTexMemBar::draw()
         S32 max_total_mem = LLViewerImage::sMaxTotalTextureMemInMegaBytes;
         F32 discard_bias = LLViewerImage::sDesiredDiscardBias;
         S32 line_height = (S32)(LLFontGL::getFontMonospace()->getLineHeight() + .5f);
+        F32 cache_usage = ((F32)(LLAppViewer::getTextureCache()->getUsage()/1024))/1024.f;
+        F32 cache_max_usage = ((F32)(LLAppViewer::getTextureCache()->getMaxUsage()/1024))/1024.f;
+//      U32 cache_entries = LLAppViewer::getTextureCache()->getEntries();
+//      U32 cache_max_entries = LLAppViewer::getTextureCache()->getMaxEntries();
         
         //----------------------------------------------------------------------------
         LLGLSUIDefault gls_ui;
-        F32 text_color[] = {1.f, 1.f, 1.f, 0.75f};
+        LLColor4 text_color(1.f, 1.f, 1.f, 0.75f);
+        LLColor4 color;
         
         std::string text;
-        text = llformat("GL Tot: %d/%d MB Bound: %d/%d MB Discard Bias: %.2f",
+        text = llformat("GL Tot: %d/%d MB Bound: %d/%d MB Raw Tot: %d MB Bias: %.2f Cache: %.1f/%.1f MB",
                                         total_mem,
                                         max_total_mem,
                                         bound_mem,
                                         max_bound_mem,
-                                        discard_bias);
+                                        LLImageRaw::sGlobalRawMemory >> 20,                                     discard_bias,
+                                        cache_usage, cache_max_usage);
+        //, cache_entries, cache_max_entries
 
         LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0, line_height*3,
-                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+                                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
 
         //----------------------------------------------------------------------------
-        S32 bar_left = 380;
+#if 0
+        S32 bar_left = 400;
         S32 bar_width = 200;
         S32 top = line_height*3 - 2;
         S32 bottom = top - 6;
         S32 left = bar_left;
         S32 right = left + bar_width;
-
-        F32 bar_scale = (F32)bar_width / (max_bound_mem * 1.5f);
+        F32 bar_scale;
         
         gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-        
-        gGL.color4f(0.5f, 0.5f, 0.5f, 0.75f);
-        gl_rect_2d(left, top, right, bottom);
 
-        
+        // GL Mem Bar
+                
         left = bar_left;
-        right = left + llfloor(bound_mem * bar_scale);
-        if (bound_mem < llfloor(max_bound_mem * texmem_lower_bound_scale))
-        {
-                gGL.color4f(0.f, 1.f, 0.f, 0.75f);
-        }
-        else if (bound_mem < max_bound_mem)
-        {
-                gGL.color4f(1.f, 1.f, 0.f, 0.75f);
-        }
-        else
-        {
-                gGL.color4f(1.f, 0.f, 0.f, 0.75f);
-        }
+        text = "GL";
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, left, line_height*3,
+                                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+        
+        left = bar_left+20;
+        right = left + bar_width;
+        
+        gGL.color4f(0.5f, 0.5f, 0.5f, 0.75f); // grey
         gl_rect_2d(left, top, right, bottom);
 
         bar_scale = (F32)bar_width / (max_total_mem * 1.5f);
+        right = left + llfloor(total_mem * bar_scale);
+        right = llclamp(right, bar_left, bar_left + bar_width);
+        
+        color = (total_mem < llfloor(max_total_mem * texmem_lower_bound_scale)) ? LLColor4::green :
+                        (total_mem < max_total_mem) ? LLColor4::yellow : LLColor4::red;
+        color[VALPHA] = .75f;
+        glColor4fv(color.mV);
         
-        top = bottom - 2;
-        bottom = top - 6;
+        gl_rect_2d(left, top, right, bottom); // red/yellow/green
+
+        //
+        bar_left += bar_width + bar_space;
+        //top = bottom - 2; bottom = top - 6;
+        
+        // Bound Mem Bar
+
         left = bar_left;
-        right = left + llfloor(total_mem * bar_scale);
-        if (total_mem < llfloor(max_total_mem * texmem_lower_bound_scale))
-        {
-                gGL.color4f(0.f, 1.f, 0.f, 0.75f);
-        }
-        else if (total_mem < max_total_mem)
-        {
-                gGL.color4f(1.f, 1.f, 0.f, 0.75f);
-        }
-        else
-        {
-                gGL.color4f(1.f, 0.f, 0.f, 0.75f);
-        }
+        text = "GL";
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, left, line_height*3,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+        left = bar_left + 20;
+        right = left + bar_width;
+        
+        gGL.color4f(0.5f, 0.5f, 0.5f, 0.75f);
         gl_rect_2d(left, top, right, bottom);
 
+        color = (bound_mem < llfloor(max_bound_mem * texmem_lower_bound_scale)) ? LLColor4::green :
+                        (bound_mem < max_bound_mem) ? LLColor4::yellow : LLColor4::red;
+        color[VALPHA] = .75f;
+        glColor4fv(color.mV);
+
+        gl_rect_2d(left, top, right, bottom);
+#else
+        S32 left = 0 ;
+#endif
         //----------------------------------------------------------------------------
 
-        text = llformat("Textures: Count: %d Fetch: %d(%d) Pkts:%d(%d) Cache R/W: %d/%d LFS:%d IW:%d(%d) RAW:%d mRaw:%d mAux:%d CB:%d",
+        text = llformat("Textures: %d Fetch: %d(%d) Pkts:%d(%d) Cache R/W: %d/%d LFS:%d IW:%d RAW:%d HTP:%d",
                                         gImageList.getNumImages(),
                                         LLAppViewer::getTextureFetch()->getNumRequests(), LLAppViewer::getTextureFetch()->getNumDeletes(),
                                         LLAppViewer::getTextureFetch()->mPacketCount, LLAppViewer::getTextureFetch()->mBadPacketCount, 
@@ -473,6 +490,16 @@ void LLGLTexMemBar::draw()
 
         LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0, line_height*2,
                                                                          text_color, LLFontGL::LEFT, LLFontGL::TOP);
+
+
+        left = 550;
+        F32 bandwidth = LLAppViewer::getTextureFetch()->getTextureBandwidth();
+        F32 max_bandwidth = gSavedSettings.getF32("ThrottleBandwidthKBPS");
+        color = bandwidth > max_bandwidth ? LLColor4::red : bandwidth > max_bandwidth*.75f ? LLColor4::yellow : text_color;
+        color[VALPHA] = text_color[VALPHA];
+        text = llformat("BW:%.0f/%.0f",bandwidth, max_bandwidth);
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, left, line_height*2,
+                                                                                         color, LLFontGL::LEFT, LLFontGL::TOP);
         
         S32 dx1 = 0;
         if (LLAppViewer::getTextureFetch()->mDebugPause)
@@ -521,6 +548,69 @@ LLRect LLGLTexMemBar::getRequiredRect()
 }
 
 ////////////////////////////////////////////////////////////////////////////
+class LLGLTexSizeBar
+{
+public:
+        LLGLTexSizeBar(S32 index, S32 left, S32 bottom, S32 right, S32 line_height)
+        {
+                mIndex = index ;
+                mLeft = left ;
+                mBottom = bottom ;
+                mRight = right ;
+                mLineHeight = line_height ;
+                mTopLoaded = 0 ;
+                mTopBound = 0 ;
+                mScale = 1.0f ;
+        }
+
+        void setTop(S32 loaded, S32 bound, F32 scale) {mTopLoaded = loaded ; mTopBound = bound; mScale = scale ;}
+
+        void draw();    
+        BOOL handleHover(S32 x, S32 y, MASK mask, BOOL set_pick_size) ;
+        
+private:
+        S32 mIndex ;
+        S32 mLeft ;
+        S32 mBottom ;
+        S32 mRight ;
+        S32 mTopLoaded ;
+        S32 mTopBound ;
+        S32 mLineHeight ;
+        F32 mScale ;
+};
+
+BOOL LLGLTexSizeBar::handleHover(S32 x, S32 y, MASK mask, BOOL set_pick_size) 
+{
+        if(y > mBottom && (y < mBottom + (S32)(mTopLoaded * mScale) || y < mBottom + (S32)(mTopBound * mScale)))
+        {
+                LLImageGL::setCurTexSizebar(mIndex, set_pick_size);
+        }
+        return TRUE ;
+}
+void LLGLTexSizeBar::draw()
+{
+        LLGLSUIDefault gls_ui;
+
+        if(LLImageGL::sCurTexSizeBar == mIndex)
+        {
+                F32 text_color[] = {1.f, 1.f, 1.f, 0.75f};      
+                std::string text;
+        
+                text = llformat("%d", mTopLoaded) ;
+                LLFontGL::getFontMonospace()->renderUTF8(text, 0, mLeft, mBottom + (S32)(mTopLoaded * mScale) + mLineHeight,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+
+                text = llformat("%d", mTopBound) ;
+                LLFontGL::getFontMonospace()->renderUTF8(text, 0, (mLeft + mRight) / 2, mBottom + (S32)(mTopBound * mScale) + mLineHeight,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+        }
+
+        F32 loaded_color[] = {1.0f, 0.0f, 0.0f, 0.75f};
+        F32 bound_color[] = {1.0f, 1.0f, 0.0f, 0.75f};
+        gl_rect_2d(mLeft, mBottom + (S32)(mTopLoaded * mScale), (mLeft + mRight) / 2, mBottom, loaded_color) ;
+        gl_rect_2d((mLeft + mRight) / 2, mBottom + (S32)(mTopBound * mScale), mRight, mBottom, bound_color) ;
+}
+////////////////////////////////////////////////////////////////////////////
 
 LLTextureView::LLTextureView(const std::string& name, const LLRect& rect)
         :       LLContainerView(name, rect),
@@ -591,7 +681,13 @@ void LLTextureView::draw()
                                                 << "\t" << cur_discard
                                                 << llendl;
                         }
-                
+
+                        if (imagep->getID() == LLAppViewer::getTextureFetch()->mDebugID)
+                        {
+                                static S32 debug_count = 0;
+                                ++debug_count; // for breakpoints
+                        }
+                        
 #if 0
                         if (imagep->getDontDiscard())
                         {
@@ -792,4 +888,301 @@ BOOL LLTextureView::handleKey(KEY key, MASK mask, BOOL called_from_parent)
         return FALSE;
 }
 
+//-----------------------------------------------------------------
+LLTextureSizeView::LLTextureSizeView(const std::string& name) : LLView(name, FALSE)
+{
+        setVisible(FALSE) ;
+
+        mTextureSizeBarWidth = 30 ;
+}
+
+LLTextureSizeView::~LLTextureSizeView()
+{
+        if(mTextureSizeBar.size())
+        {
+                for(U32 i = 0 ; i < mTextureSizeBar.size() ; i++)
+                {
+                        delete mTextureSizeBar[i] ;
+                }
+                mTextureSizeBar.clear() ;
+        }
+}
+void LLTextureSizeView::draw()
+{
+        if(mType == TEXTURE_MEM_OVER_SIZE)
+        {
+                drawTextureSizeGraph();
+        }
+        else
+        {
+                drawTextureCategoryGraph() ;
+        }
+        
+        LLView::draw();
+}
+
+BOOL LLTextureSizeView::handleHover(S32 x, S32 y, MASK mask) 
+{
+        if(x > mTextureSizeBarRect.mLeft && x < mTextureSizeBarRect.mRight)
+        {
+                mTextureSizeBar[(x - mTextureSizeBarRect.mLeft) / mTextureSizeBarWidth]->handleHover(x, y, mask, (mType == TEXTURE_MEM_OVER_SIZE)) ;
+        }
+
+        return TRUE ;
+}
+
+//draw real-time texture mem bar over size
+void LLTextureSizeView::drawTextureSizeGraph()
+{
+        if(mTextureSizeBar.size() == 0)
+        {
+                S32 line_height = (S32)(LLFontGL::getFontMonospace()->getLineHeight() + .5f);
+                mTextureSizeBar.resize(LLImageGL::sTextureLoadedCounter.size()) ;
+                mTextureSizeBarRect.set(700, line_height * 2 + 400, 700 + mTextureSizeBar.size() * mTextureSizeBarWidth, line_height * 2) ;
+                
+                for(U32 i = 0 ; i < mTextureSizeBar.size() ; i++)
+                {                               
+                        mTextureSizeBar[i] = new LLGLTexSizeBar(i, mTextureSizeBarRect.mLeft + i * mTextureSizeBarWidth , 
+                                line_height * 2, mTextureSizeBarRect.mLeft + (i + 1) * mTextureSizeBarWidth, line_height) ;                             
+                }                       
+        }
 
+        F32 size_bar_scale = drawTextureSizeDistributionGraph() ;               
+        for(U32 i = 0 ; i < mTextureSizeBar.size() ; i++)
+        {
+                mTextureSizeBar[i]->setTop(LLImageGL::sTextureLoadedCounter[i], LLImageGL::sTextureBoundCounter[i], size_bar_scale) ;
+                mTextureSizeBar[i]->draw() ;
+        }               
+        LLImageGL::resetCurTexSizebar();
+}
+
+//draw background of texture size bar graph
+F32 LLTextureSizeView::drawTextureSizeDistributionGraph()
+{       
+        //scale
+        F32 scale = 1.0f ;
+        
+        LLGLSUIDefault gls_ui;
+
+        {
+                S32 count = 0 ;
+                for(U32 i = 0 ; i < LLImageGL::sTextureLoadedCounter.size() ; i++)
+                {
+                        if(LLImageGL::sTextureLoadedCounter[i] > count)
+                        {
+                                count = LLImageGL::sTextureLoadedCounter[i] ;
+                        }
+                }
+                if(count > mTextureSizeBarRect.getHeight())
+                {
+                        scale = (F32)mTextureSizeBarRect.getHeight() / count ;
+                }
+        }
+
+        S32 line_height = (S32)(LLFontGL::getFontMonospace()->getLineHeight() + .5f);
+        S32 left = mTextureSizeBarRect.mLeft ;
+        S32 bottom = mTextureSizeBarRect.mBottom ;
+        S32 right = mTextureSizeBarRect.mRight ;
+        S32 top = mTextureSizeBarRect.mTop ;
+
+        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+        
+        //background rect
+        gl_rect_2d(left - 25, top + 30, right + 100, bottom - 25, LLColor4(0.0f, 0.0f, 0.0f, 0.25f)) ;
+
+        //--------------------------------------------------
+        gGL.color4f(1.0f, 0.5f, 0.5f, 0.75f);
+        gl_line_2d(left, bottom, right, bottom) ; //x axis
+        gl_line_2d(left, bottom, left, top) ; //y axis
+
+        //ruler
+        //--------------------------------------------------
+        gGL.color4f(1.0f, 0.5f, 0.5f, 0.5f);
+        for(S32 i = bottom + 50 ; i <= top ; i += 50)
+        {
+                gl_line_2d(left, i, right, i) ;
+        }
+
+        //texts
+        //--------------------------------------------------
+        F32 text_color[] = {1.f, 1.f, 1.f, 0.75f};      
+        std::string text;
+        
+        //-------
+        //x axis: size label
+        text = llformat("%d", 0) ;
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 12, bottom - line_height / 2,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+        for(U32 i = 1 ; i < mTextureSizeBar.size() ; i++)
+        {
+                text = llformat("%d", (1 << (i / 2)) + ((i & 1) ? ((1 << (i / 2)) >> 1) : 0)) ;
+                LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + i * mTextureSizeBarWidth + 12, bottom - line_height / 2,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+        }
+        text = llformat("(w + h)/2") ;
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, right + 10, bottom - line_height / 2,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+        //-------
+
+        //y axis: number label
+        for(S32 i = bottom + 50 ; i <= top ; i += 50)
+        {
+                text = llformat("%d", (S32)((i - bottom) / scale)) ;
+                LLFontGL::getFontMonospace()->renderUTF8(text, 0, left - 20, i + line_height / 2 ,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+                LLFontGL::getFontMonospace()->renderUTF8(text, 0, right + 5, i + line_height / 2 ,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+        }
+
+        //--------------------------------------------------
+        F32 loaded_color[] = {1.0f, 0.0f, 0.0f, 0.75f};
+        gl_rect_2d(left + 70, top + line_height * 2, left + 90, top + line_height, loaded_color) ;
+        text = llformat("Loaded") ;
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 100, top + line_height * 2,
+                                                                         loaded_color, LLFontGL::LEFT, LLFontGL::TOP);
+
+        F32 bound_color[] = {1.0f, 1.0f, 0.0f, 0.75f};
+        gl_rect_2d(left + 170, top + line_height * 2, left + 190, top + line_height, bound_color) ;
+        text = llformat("Bound") ;
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 200, top + line_height * 2,
+                                                                         bound_color, LLFontGL::LEFT, LLFontGL::TOP);
+
+        //--------------------------------------------------
+
+        //title
+        text = llformat("Texture Size Distribution") ;
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 250, top + line_height * 3,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+        return scale ;
+}
+
+//draw real-time texture mem bar over category
+void LLTextureSizeView::drawTextureCategoryGraph()
+{
+        if(mTextureSizeBar.size() == 0)
+        {
+                S32 line_height = (S32)(LLFontGL::getFontMonospace()->getLineHeight() + .5f);
+                mTextureSizeBar.resize(LLImageGL::sTextureMemByCategory.size()) ;
+                mTextureSizeBarRect.set(700, line_height * 2 + 400, 700 + mTextureSizeBar.size() * mTextureSizeBarWidth, line_height * 2) ;
+                
+                for(U32 i = 0 ; i < mTextureSizeBar.size() ; i++)
+                {                               
+                        mTextureSizeBar[i] = new LLGLTexSizeBar(i, mTextureSizeBarRect.mLeft + i * mTextureSizeBarWidth , 
+                                line_height * 2, mTextureSizeBarRect.mLeft + (i + 1) * mTextureSizeBarWidth, line_height) ;                             
+                }                       
+        }
+
+        F32 size_bar_scale = drawTextureCategoryDistributionGraph() ;           
+        for(U32 i = 0 ; i < mTextureSizeBar.size() ; i++)
+        {
+                mTextureSizeBar[i]->setTop(LLImageGL::sTextureMemByCategory[i] >> 20, LLImageGL::sTextureMemByCategoryBound[i] >> 20, size_bar_scale) ;
+                mTextureSizeBar[i]->draw() ;
+        }               
+        LLImageGL::resetCurTexSizebar();
+}
+
+//draw background for TEXTURE_MEM_OVER_CATEGORY
+F32 LLTextureSizeView::drawTextureCategoryDistributionGraph() 
+{
+        //scale
+        F32 scale = 4.0f ;
+        
+        LLGLSUIDefault gls_ui;
+
+        {
+                S32 count = 0 ;
+                for(U32 i = 0 ; i < LLImageGL::sTextureMemByCategory.size() ; i++)
+                {
+                        S32 tmp = LLImageGL::sTextureMemByCategory[i] >> 20 ;
+                        if(tmp > count)
+                        {
+                                count = tmp ;
+                        }
+                }
+                if(count > mTextureSizeBarRect.getHeight() * 0.25f)
+                {
+                        scale = (F32)mTextureSizeBarRect.getHeight() * 0.25f / count ;
+                }
+        }
+
+        S32 line_height = (S32)(LLFontGL::getFontMonospace()->getLineHeight() + .5f);
+        S32 left = mTextureSizeBarRect.mLeft ;
+        S32 bottom = mTextureSizeBarRect.mBottom ;
+        S32 right = mTextureSizeBarRect.mRight ;
+        S32 top = mTextureSizeBarRect.mTop ;
+
+        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+        
+        //background rect
+        gl_rect_2d(left - 25, top + 30, right + 100, bottom - 25, LLColor4(0.0f, 0.0f, 0.0f, 0.25f)) ;
+
+        //--------------------------------------------------
+        gGL.color4f(1.0f, 0.5f, 0.5f, 0.75f);
+        gl_line_2d(left, bottom, right, bottom) ; //x axis
+        gl_line_2d(left, bottom, left, top) ; //y axis
+
+        //ruler
+        //--------------------------------------------------
+        gGL.color4f(1.0f, 0.5f, 0.5f, 0.5f);
+        for(S32 i = bottom + 50 ; i <= top ; i += 50)
+        {
+                gl_line_2d(left, i, right, i) ;
+        }
+
+        //texts
+        //--------------------------------------------------
+        F32 text_color[] = {1.f, 1.f, 1.f, 0.75f};      
+        std::string text;
+        
+        //-------
+        //x axis: size label                    
+        static char category[LLViewerImageBoostLevel::MAX_GL_IMAGE_CATEGORY][4] = 
+        {"Non", "Bak", "Av", "Cld", "Scp", "Hi", "Trn", "Slt", "Hud", "Bsf", "UI", "Pvw", "Map", "Mvs", "Slf", "Tbp", "Scr", "Fnt", "Bmp", "Dyn", "Tlc", "Mdi", "ALT", "Oth" } ;
+
+        text = llformat("%s", category[0]) ;
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 12, bottom - line_height / 2,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+        for(U32 i = 1 ; i < mTextureSizeBar.size() ; i++)
+        {
+                text = llformat("%s", category[i]) ;
+                LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + i * mTextureSizeBarWidth + 12, bottom - line_height / 2,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+        }
+        //-------
+
+        //y axis: number label
+        for(S32 i = bottom + 50 ; i <= top ; i += 50)
+        {
+                text = llformat("%d", (S32)((i - bottom) / scale)) ;
+                LLFontGL::getFontMonospace()->renderUTF8(text, 0, left - 20, i + line_height / 2 ,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+                LLFontGL::getFontMonospace()->renderUTF8(text, 0, right + 5, i + line_height / 2 ,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+        }
+
+        text = llformat("MB") ;
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, left - 20, top + line_height * 2 ,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+        //--------------------------------------------------
+        F32 loaded_color[] = {1.0f, 0.0f, 0.0f, 0.75f};
+        gl_rect_2d(left + 70, top + line_height * 2, left + 90, top + line_height, loaded_color) ;
+        text = llformat("Loaded") ;
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 100, top + line_height * 2,
+                                                                         loaded_color, 
+                                                                         LLFontGL::LEFT, LLFontGL::TOP);
+
+        F32 bound_color[] = {1.0f, 1.0f, 0.0f, 0.75f};
+        gl_rect_2d(left + 170, top + line_height * 2, left + 190, top + line_height, bound_color) ;
+        text = llformat("Bound") ;
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 200, top + line_height * 2,
+                                                                         bound_color, LLFontGL::LEFT, LLFontGL::TOP);
+
+        //--------------------------------------------------
+
+        //title
+        text = llformat("Texture Category Distribution") ;
+        LLFontGL::getFontMonospace()->renderUTF8(text, 0, left + 250, top + line_height * 3,
+                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
+
+        return scale ;
+}
diff --git a/linden/indra/newview/lltextureview.h b/linden/indra/newview/lltextureview.h
index f91a296..e95c152 100644
--- a/linden/indra/newview/lltextureview.h
+++ b/linden/indra/newview/lltextureview.h
@@ -76,5 +76,40 @@ public:
         static std::set<LLViewerImage*> sDebugImages;
 };
 
+class LLGLTexSizeBar;
+class LLTextureSizeView : public LLView
+{
+public:
+        LLTextureSizeView(const std::string& name);
+        ~LLTextureSizeView();
+
+        /*virtual*/ void draw();
+        /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask) ;
+        
+        void setType(S32 type) {mType = type ;}
+        enum
+        {
+                TEXTURE_MEM_OVER_SIZE,
+                TEXTURE_MEM_OVER_CATEGORY
+        };
+private:
+        //draw background for TEXTURE_MEM_OVER_SIZE
+        F32 drawTextureSizeDistributionGraph() ;
+        //draw real-time texture mem bar over size
+        void drawTextureSizeGraph();
+
+        //draw background for TEXTURE_MEM_OVER_CATEGORY
+        F32 drawTextureCategoryDistributionGraph() ;
+        //draw real-time texture mem bar over category
+        void drawTextureCategoryGraph();
+
+private:
+        std::vector<LLGLTexSizeBar*> mTextureSizeBar ;
+        LLRect mTextureSizeBarRect ;
+        S32    mTextureSizeBarWidth ;   
+        S32    mType ;
+};
 extern LLTextureView *gTextureView;
+extern LLTextureSizeView *gTextureSizeView;
+extern LLTextureSizeView *gTextureCategoryView;
 #endif // LL_TEXTURE_VIEW_H
diff --git a/linden/indra/newview/llviewerstats.cpp b/linden/indra/newview/llviewerstats.cpp
index d12d51c..93e69ca 100644
--- a/linden/indra/newview/llviewerstats.cpp
+++ b/linden/indra/newview/llviewerstats.cpp
@@ -501,12 +501,18 @@ extern U32  gVisCompared;
 extern U32  gVisTested;
 
 std::map<S32,LLFrameTimer> gDebugTimers;
+std::map<S32,std::string> gDebugTimerLabel;
+
+void init_statistics()
+{
+        // Label debug timers
+        gDebugTimerLabel[0] = "Texture";
+}
 
 void update_statistics(U32 frame_count)
 {
         gTotalWorldBytes += gVLManager.getTotalBytes();
         gTotalObjectBytes += gObjectBits / 8;
-        gTotalTextureBytes += LLViewerImageList::sTextureBits / 8;
 
         // make sure we have a valid time delta for this frame
         if (gFrameIntervalSeconds > 0.f)
@@ -558,7 +564,6 @@ void update_statistics(U32 frame_count)
         F32 layer_bits = (F32)(gVLManager.getLandBits() + gVLManager.getWindBits() + gVLManager.getCloudBits());
         LLViewerStats::getInstance()->mLayersKBitStat.addValue(layer_bits/1024.f);
         LLViewerStats::getInstance()->mObjectKBitStat.addValue(gObjectBits/1024.f);
-        LLViewerStats::getInstance()->mTextureKBitStat.addValue(LLViewerImageList::sTextureBits/1024.f);
         LLViewerStats::getInstance()->mVFSPendingOperations.addValue(LLVFile::getVFSThread()->getPending());
         LLViewerStats::getInstance()->mAssetKBitStat.addValue(gTransferManager.getTransferBitsIn(LLTCT_ASSET)/1024.f);
         gTransferManager.resetTransferBitsIn(LLTCT_ASSET);
@@ -572,8 +577,6 @@ void update_statistics(U32 frame_count)
                 gDebugTimers[0].unpause();
         }
         
-        LLViewerStats::getInstance()->mTexturePacketsStat.addValue(LLViewerImageList::sTexturePackets);
-
         {
                 static F32 visible_avatar_frames = 0.f;
                 static F32 avg_visible_avatars = 0;
@@ -593,8 +596,20 @@ void update_statistics(U32 frame_count)
         gObjectBits = 0;
 //      gDecodedBits = 0;
 
-        LLViewerImageList::sTextureBits = 0;
-        LLViewerImageList::sTexturePackets = 0;
+        // Only update texture stats ones per second so that they are less noisy
+        {
+                static const F32 texture_stats_freq = 1.f;
+                static LLFrameTimer texture_stats_timer;
+                if (texture_stats_timer.getElapsedTimeF32() >= texture_stats_freq)
+                {
+                        LLViewerStats::getInstance()->mTextureKBitStat.addValue(LLViewerImageList::sTextureBits/1024.f);
+                        LLViewerStats::getInstance()->mTexturePacketsStat.addValue(LLViewerImageList::sTexturePackets);
+                        gTotalTextureBytes += LLViewerImageList::sTextureBits / 8;
+                        LLViewerImageList::sTextureBits = 0;
+                        LLViewerImageList::sTexturePackets = 0;
+                        texture_stats_timer.reset();
+                }
+        }
 
 #if LL_LCD_COMPILE
         bool LCDenabled = gLcdScreen->Enabled();
@@ -775,3 +790,4 @@ void send_stats()
         LLViewerStats::getInstance()->addToMessage(body);
         LLHTTPClient::post(url, body, new ViewerStatsResponder());
 }
+
diff --git a/linden/indra/newview/llviewerstats.h b/linden/indra/newview/llviewerstats.h
index d3fd4f2..b176632 100644
--- a/linden/indra/newview/llviewerstats.h
+++ b/linden/indra/newview/llviewerstats.h
@@ -34,6 +34,7 @@
 #define LL_LLVIEWERSTATS_H
 
 #include "llstat.h"
+#include "lltextureinfo.h"
 
 class LLViewerStats : public LLSingleton<LLViewerStats>
 {
@@ -198,10 +199,13 @@ private:
 static const F32 SEND_STATS_PERIOD = 300.0f;
 
 // The following are from (older?) statistics code found in appviewer.
+void init_statistics();
 void reset_statistics();
 void output_statistics(void*);
 void update_statistics(U32 frame_count);
 void send_stats();
 
 extern std::map<S32,LLFrameTimer> gDebugTimers;
+extern std::map<S32,std::string> gDebugTimerLabel;
+
 #endif // LL_LLVIEWERSTATS_H