/** * @file llfloatermemleak.cpp * @brief LLFloatermemleak class definition * * $LicenseInfo:firstyear=2007&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 "llviewerprecompiledheaders.h" #include "llfloatermemleak.h" #include "lluictrlfactory.h" #include "llbutton.h" #include "llspinctrl.h" #include "llresmgr.h" #include "llmath.h" #include "llviewerwindow.h" U32 LLFloaterMemLeak::sMemLeakingSpeed = 0 ; //bytes leaked per frame U32 LLFloaterMemLeak::sMaxLeakedMem = 0 ; //maximum allowed leaked memory U32 LLFloaterMemLeak::sTotalLeaked = 0 ; S32 LLFloaterMemLeak::sStatus = LLFloaterMemLeak::STOP ; BOOL LLFloaterMemLeak::sbAllocationFailed = FALSE ; LLFloaterMemLeak::LLFloaterMemLeak(const LLSD& key) : LLFloater(key) { setTitle("Memory Leaking Simulation Floater"); mCommitCallbackRegistrar.add("MemLeak.ChangeLeakingSpeed", boost::bind(&LLFloaterMemLeak::onChangeLeakingSpeed, this)); mCommitCallbackRegistrar.add("MemLeak.ChangeMaxMemLeaking", boost::bind(&LLFloaterMemLeak::onChangeMaxMemLeaking, this)); mCommitCallbackRegistrar.add("MemLeak.Start", boost::bind(&LLFloaterMemLeak::onClickStart, this)); mCommitCallbackRegistrar.add("MemLeak.Stop", boost::bind(&LLFloaterMemLeak::onClickStop, this)); mCommitCallbackRegistrar.add("MemLeak.Release", boost::bind(&LLFloaterMemLeak::onClickRelease, this)); mCommitCallbackRegistrar.add("MemLeak.Close", boost::bind(&LLFloaterMemLeak::onClickClose, this)); } //---------------------------------------------- BOOL LLFloaterMemLeak::postBuild(void) { F32 a, b ; a = getChild<LLUICtrl>("leak_speed")->getValue().asReal(); if(a > (F32)(0xFFFFFFFF)) { sMemLeakingSpeed = 0xFFFFFFFF ; } else { sMemLeakingSpeed = (U32)a ; } b = getChild<LLUICtrl>("max_leak")->getValue().asReal(); if(b > (F32)0xFFF) { sMaxLeakedMem = 0xFFFFFFFF ; } else { sMaxLeakedMem = ((U32)b) << 20 ; } sbAllocationFailed = FALSE ; return TRUE ; } LLFloaterMemLeak::~LLFloaterMemLeak() { release() ; sMemLeakingSpeed = 0 ; //bytes leaked per frame sMaxLeakedMem = 0 ; //maximum allowed leaked memory } void LLFloaterMemLeak::release() { if(mLeakedMem.empty()) { return ; } for(S32 i = 0 ; i < (S32)mLeakedMem.size() ; i++) { delete[] mLeakedMem[i] ; } mLeakedMem.clear() ; sStatus = STOP ; sTotalLeaked = 0 ; sbAllocationFailed = FALSE ; } void LLFloaterMemLeak::stop() { sStatus = STOP ; sbAllocationFailed = TRUE ; } void LLFloaterMemLeak::idle() { if(STOP == sStatus) { return ; } sbAllocationFailed = FALSE ; if(RELEASE == sStatus) { release() ; return ; } char* p = NULL ; if(sMemLeakingSpeed > 0 && sTotalLeaked < sMaxLeakedMem) { p = new char[sMemLeakingSpeed] ; if(p) { mLeakedMem.push_back(p) ; sTotalLeaked += sMemLeakingSpeed ; } } if(!p) { sStatus = STOP ; sbAllocationFailed = TRUE ; } } //---------------------- void LLFloaterMemLeak::onChangeLeakingSpeed() { F32 tmp ; tmp =getChild<LLUICtrl>("leak_speed")->getValue().asReal(); if(tmp > (F32)0xFFFFFFFF) { sMemLeakingSpeed = 0xFFFFFFFF ; } else { sMemLeakingSpeed = (U32)tmp ; } } void LLFloaterMemLeak::onChangeMaxMemLeaking() { F32 tmp ; tmp =getChild<LLUICtrl>("max_leak")->getValue().asReal(); if(tmp > (F32)0xFFF) { sMaxLeakedMem = 0xFFFFFFFF ; } else { sMaxLeakedMem = ((U32)tmp) << 20 ; } } void LLFloaterMemLeak::onClickStart() { sStatus = START ; } void LLFloaterMemLeak::onClickStop() { sStatus = STOP ; } void LLFloaterMemLeak::onClickRelease() { sStatus = RELEASE ; } void LLFloaterMemLeak::onClickClose() { setVisible(FALSE); } void LLFloaterMemLeak::draw() { //show total memory leaked if(sTotalLeaked > 0) { std::string bytes_string; LLResMgr::getInstance()->getIntegerString(bytes_string, sTotalLeaked >> 10 ); getChild<LLUICtrl>("total_leaked_label")->setTextArg("[SIZE]", bytes_string); } else { getChild<LLUICtrl>("total_leaked_label")->setTextArg("[SIZE]", LLStringExplicit("0")); } if(sbAllocationFailed) { getChild<LLUICtrl>("note_label_1")->setTextArg("[NOTE1]", LLStringExplicit("Memory leaking simulation stops. Reduce leaking speed or")); getChild<LLUICtrl>("note_label_2")->setTextArg("[NOTE2]", LLStringExplicit("increase max leaked memory, then press Start to continue.")); } else { getChild<LLUICtrl>("note_label_1")->setTextArg("[NOTE1]", LLStringExplicit("")); getChild<LLUICtrl>("note_label_2")->setTextArg("[NOTE2]", LLStringExplicit("")); } LLFloater::draw(); }