精华内容
下载资源
问答
  • 自周四起,服务器的CPU与内存使用率持续处于过饱合状态,并因此导致了数次宕机(期间有几次宕机是应用服务器宕机)。 2、问题观察  通过观察,发现如下几个疑似问题:  1)在无任何作业的情况下,存在数十个...

     

     1、问题描述

     

      某客户系统采用三层架构:数据库—应用服务—前端应用。其中数据库使用PostgreSQL 10.0作为数据库软件。自周四起,服务器的CPU与内存使用率持续处于过饱合状态,并因此导致了数次宕机(期间有几次宕机是应用服务器宕机)。

     2、问题观察

      通过观察,发现如下几个疑似问题:

      1)在无任何作业的情况下,存在数十个处于空闲状态的服务器进程(即postgres进程),这些进程虽然不消耗CPU,但始终持有内存资源;

         2)开启慢查询之后发现,有三类SQL查询效率非常低。

                  1、根据输入的WKT(矩形范围)作空间相交分析。如下图(耗时30s以上)

        2、DCTB表与DDXX表的JOIN查询,如下图耗时5-14s:

      3、执行COMMIT提交事务后的等待,如下图耗时10-30s

    3、问题分析

      1)针对空闲进程的处理:一方面,应用程序(Tomcat)要使用连接池,且要设计有效的回收连接的机制;二方面,在数据库层面设置TCP探针,每隔10s探测一下client process是否仍然处于active状态,如果客户端进程已经异常关闭,数据库会回收连接。

      2)针对空间相交分析的SQL,经分析是由于public.dctb的geom字段上未创建空间索引,导致每次的相交分析(即&&操作符)都需要判断所有要素与WKT矩形的空间关系。空间运算属于CPU密集型操作,操作系统的CPU使用率长期过饱合可能与此有关。

      创建空间索引:create index idx_dctb_geom on public.dctb using gist (geom),持续运行一段时间后观察到CPU的使用率有明显缓解。

      3)针对JOIN查询慢的问题,原本认为可能是因为SQL写法的原因,导致查询优化器选择了错误的执行计划。但经过分析执行计划,发现该SQL的确是先通过索引过滤了部分记录,然后再执行JOIN连接,因此对该问题的优化需要考虑其它的办法。但这并不代表该SQL不需要优化,从SQL的易读性和避免查询优化器选择了错误的执行计划这两个方面考虑,建议把SQL改写成类似如下的写法:

    with t3 as (select r_rybh from rwdd.sbxx where mac = '74:d2:1d:b3:a2:bc' limit 1),

    t2 as (select bsm,coalesce(sfjz,'Y') sfjz,sjly from dctb where xzqdm='370322')

    select t1.bsm,coalesce(t1.tbzt3,'00') tbzt3,t2.sfjz,t2.sjly,t1.shjg1 shjg1,

            t1.shyj1 shyj1,

            t1.shjg2 shjg2,

            t1.shyj2 shyj2,

            t1.shjg3 shjg3,

            t1.shyj3 shyj3,

            t1.wyhczt wyhczt,case when COALESCE(t3.r_rybh,'0') = '0' then '0' else '1' end as sfzpbj from ddxx t1 left join t3 on t1.rybh=t3.r_rybh join t2 on t1.bsm=t2.bsm

      4)针对COMMIT延迟的问题,考虑从如下两方面解决:

        1、对虚拟磁盘作基准测试,因为怀疑磁盘的IOPS本身就不高。

        A.连续读的性能:

    以7200转SATA盘连续读性能作为参考,如下:

        B.随机读性能

    以7200转SATA盘连续读性能作为参考,如下:

    通过基础测试可知,虚拟磁盘的性能超过7200转的SATA盘,与10000-15000转SAS盘性能相当

        2、通过修改数据库参数文件,优化WAL日志写的效率

    修改的参数包括:

    synchronous_commit 由 on 改为了 off

    wal_buffers 由100MB 改为了 400MB

    commit_delay 由0 改为了 100

    wal_compression 由 off 改为了 on

          3、其它调整

    A.调整了部分内存池的设置。

    包括work_mem = 20MB和 maintenance_work_mem = 20MB

    B.关闭了autovacuum

    4、目前情况

    收集了3月18日13:30到21点的部分性能数据,分析如下:

      1)Processor Time

     

     

    Processor Time基本上处于50%左右。

      2)磁盘读写MB/s

    磁盘读写普遍处于10M/s以下。

      3)可用内存(GB)

    可用内存长期保持8G左右。

    转载于:https://www.cnblogs.com/6yuhang/p/10756725.html

    展开全文
  • 即席式工作负荷优化 在SQL Server中执行代码时,代码会生成一个哈希值,并使用哈希值确认计划的重用,如果执行一个存储过程,存储过程的名称会生成一个哈希值,后续的每一个存储过程调用不管使用的参数是否与之前的...

    即席式工作负荷优化

    在SQL Server中执行代码时,代码会生成一个哈希值,并使用哈希值确认计划的重用,如果执行一个存储过程,存储过程的名称会生成一个哈希值,后续的每一个存储过程调用不管使用的参数是否与之前的相同,都会重用该计划。

    如果运行除了存储过程以外的同样的代码啊(也就是即席T-SQL),包含代码中所有文字的整段代码将会生成哈希值。当改变了代码中的任何文字再次执行语句,新的哈希值与之前的就不同乐,因此会生成一个新的执行计划。

    这种情况会导致被称为计划缓存膨胀(plan cache bloat)的场景,既可能有成千上万的即席查询的执行计划被生成和缓存,虽然从根本上说代码时相同的,单这些计划的使用次数只有1。理想的解决方案是用时存储过程或函数,或讲所有即席T-SQL都进行参数化,但是往往无法实现。

    针对即席工作负荷进行优化(Optimize for Ad-hoc Workloads)选项

    启用这个选项是,当一段即席T-SQL第一次执行时,SQL Server将执行计划的存根进行缓存,而不是完整计划。如果SQL Server随后尝试重用改计划,执行计划将再次生成,但这次执行计划全部被缓存,这避免了成千上万地一次性使用的执行计划在缓存中占用宝贵空间。

    例如,显示计划缓存大小:

    -- Single use adhoc plans
    select count(*) as 'Number of Plans',
    	sum(cast(size_in_bytes as bigint))/1024/1024 as 'Plan Cache Size(MB)'
    from sys.dm_exec_cached_plans
    
    结果
    Number of Plans Plan Cache Size(MB)
    --------------- --------------------
    2               0
    

    显示计划缓存中各缓存对象类型的大小:

    -- Cache size by object type
    SELECT objtype AS 'Cached Object Type',
    count(*) AS 'Number of Plans',
    sum(cast(size_in_bytes AS BIGINT))/1024/1024 AS 'Plan Cache Size (MB)',
    avg(usecounts) AS 'Avg Use Count'
    FROM sys.dm_exec_cached_plans
    GROUP BY objtype
    
    结果
    Cached Object Type   Number of Plans Plan Cache Size (MB) Avg Use Count
    -------------------- --------------- -------------------- -------------
    View                 1               0                    6
    Adhoc                3               2                    1

    其中Adhoc为即席计划,Plan Cache Size(MB)为大小,Avg User Count 为平均使用次数

    显示即席计划缓存中,只使用了一次的执行计划:

    -- Single use adhoc plans
    SELECT count(*) AS 'Number of Plans',
    sum(cast(size_in_bytes AS BIGINT))/1024/1024 AS 'Plan Cache Size (MB)'
    FROM sys.dm_exec_cached_plans
    WHERE usecounts = 1
    AND objtype = 'adhoc'
    
    结果
    Number of Plans Plan Cache Size (MB)
    --------------- --------------------
    1               0

     

    总结:针对即席工作负荷进行优化的选中能够确保不缓存不能重复使用的计划,可以节省服务器内存,并且仅影响即席计划,建议在所有SQL Server安装中默认都打开这个选项。

    展开全文
  • 测试内存申请速度的小工具 目的 1、 采用动态分配内存的方式进行测试,要求内存拷贝的操作时间...3、 测试过程中需要考虑系统内存负荷达到百分之80的情况; #include "Stdafx.h" #include <iostream> #includ...

    目的

    1、 采用动态分配内存的方式进行测试,要求内存拷贝的操作时间不能超过500ms;连续内存拷贝耗时超过300ms的连续次数不能超过3次;
    2、 测试需要覆盖从小块内存的拷贝到大块内存的申请和拷贝的情况;
    3、 测试过程中需要考虑系统内存负荷达到百分之80的情况;

    #include "Stdafx.h"
    #include <iostream>
    #include <sstream>
    #include <fstream>
    #include <stdint.h> 
    #include "Markup.h"
    #include "ipp/ipp.h"
    #include <string>
    #include <time.h>
    #include <vector>
    #include <boost/format.hpp>   
    #include <boost/tokenizer.hpp>   
    #include <boost/filesystem/path.hpp>
    #include <boost/filesystem/operations.hpp>
    #include <boost/algorithm/string.hpp>  
    #define time_shift  (uint64_t)116444736000000000ULL // (27111902 << 32) + 3577643008 
    using namespace std;
    
    char filename[60]="";
    char reportFilename[60]="";
    int iAllLoopCount=0;//总循环次数
    double dNewThreshold,d4KThreshold,dMemsetThreshold,dMemcpyThreshold;
    
    class TmePerofrmanceCount
    {
    public:
        static LARGE_INTEGER StartTiming();
        static double EndTiming(LARGE_INTEGER &nStartTime);
        static int64_t m_nCPUFreq;
    };
    
    struct TestItem
    {
    	int64_t iSize;
    	int iLoopCount;
    	int iAllLoopCount;
    	double dOrgMem;
    	int iInitType;
    };
    
    int64_t TmePerofrmanceCount::m_nCPUFreq = 0;
    
    LARGE_INTEGER TmePerofrmanceCount::StartTiming()
    {
        LARGE_INTEGER nFreq;
        ::QueryPerformanceFrequency(&nFreq);
        m_nCPUFreq = nFreq.QuadPart;
    
        LARGE_INTEGER nStartTime;
        ::QueryPerformanceCounter(&nStartTime);
        return nStartTime;
    }
    
    double TmePerofrmanceCount::EndTiming(LARGE_INTEGER &nStartTime)
    {
        LARGE_INTEGER nEndTime;
        ::QueryPerformanceCounter(&nEndTime);
        return 1000*(nEndTime.QuadPart-nStartTime.QuadPart)/(double)m_nCPUFreq;
    }
    
    void SetProcessPriority()
    {
        HANDLE hPS = ::OpenProcess( PROCESS_ALL_ACCESS, false, ::GetCurrentProcessId() );
        BOOL bSetRealTimeRet = ::SetPriorityClass( hPS, REALTIME_PRIORITY_CLASS );
        if (!bSetRealTimeRet)
        {
            if (INVALID_HANDLE_VALUE != hPS)
            {
                if (!::SetPriorityClass( hPS, REALTIME_PRIORITY_CLASS ))
                {
                    throw std::logic_error("Set RDM REALTIME failed.");
                }
            }
        }
        ::CloseHandle( hPS );
    }
    
    void ReconMemSet(char *pDataPointer, int64_t &iMemSize)
    {
        int64_t i4K = 4096;
        int64_t iCurPos = 512;
        do 
        {
            *(pDataPointer+iCurPos) = 100;
            iCurPos += i4K;
        } while (iCurPos < iMemSize);
    }
    
    void RDMTestLog(std::string &strContent,const char* filename)
    {  
        {
            FILETIME ft; 
            GetSystemTimeAsFileTime(&ft);
            union { 
                FILETIME as_file_time;
                uint64_t as_integer; 
            } time_caster;
            time_caster.as_file_time = ft; 
            time_caster.as_integer -= time_shift;
            uint64_t iTempValue = time_caster.as_integer/10000UL;
            std::ofstream f1(filename,  std::ios::out|std::ios::app);
    		f1 <<strContent.c_str();
            f1.flush();
            f1.close();
        }
    }
    void memcpytest(struct TestItem &OneTest)
    {
    	int64_t i1024 = 1024;
    	int64_t iSizeOrg;
    	std::stringstream sssLog;
    	double dMemsetavg = 0.0;
    	double dMaxTime=0.0,dMinTime=10000000.0,dAvgTime=0.0;
        double dElapsed4k=0;
        double dElapsedMemset=0;
        int64_t iCpyLoopCount;
        char *pdataCpy = new char[OneTest.iSize];
    
        if(OneTest.dOrgMem<1&&OneTest.dOrgMem*1000>1)
        {
            iSizeOrg=i1024*i1024*OneTest.dOrgMem*1000;
        }
        else  
            iSizeOrg=i1024*i1024*i1024*OneTest.dOrgMem;
        
        
        if(OneTest.iSize<0.0001)
        {
            return;
        }
        iCpyLoopCount = iSizeOrg/OneTest.iSize;
        try
    	{	
    		for (int i=0; i<OneTest.iSize; i++)
    		{
    			*(pdataCpy+i) = i%200;
    		}
    		for (int i=0; i<OneTest.iLoopCount; i++)
    		{   
                LARGE_INTEGER newStart = TmePerofrmanceCount::StartTiming();
    			char *pData = new char[iSizeOrg];
                double dnewElapsed = TmePerofrmanceCount::EndTiming(newStart);
    			if(1==OneTest.iInitType)
    			{
    				LARGE_INTEGER Start4k = TmePerofrmanceCount::StartTiming();
    				ReconMemSet(pData, iSizeOrg);
    				dElapsed4k = TmePerofrmanceCount::EndTiming(Start4k);
    			}
    			else
    			{
                    if (2==OneTest.iInitType)
                    {
                        LARGE_INTEGER StartMemset = TmePerofrmanceCount::StartTiming();
                        memset(pData,0, iSizeOrg);
                        dElapsedMemset = TmePerofrmanceCount::EndTiming(StartMemset);
                    }
    			}
    			LARGE_INTEGER lgStartallcpy = TmePerofrmanceCount::StartTiming();
    			for (int j=0; j<iCpyLoopCount; j++)
    			{
    				LARGE_INTEGER lgStartcpy = TmePerofrmanceCount::StartTiming();
    				memcpy(pData+j*OneTest.iSize, pdataCpy, OneTest.iSize);
    				double dElapsedcpy = TmePerofrmanceCount::EndTiming(lgStartcpy);
    				if(dMaxTime<dElapsedcpy)
    					dMaxTime=dElapsedcpy;
    				if(dMinTime>dElapsedcpy)
    					dMinTime=dElapsedcpy;
                    dAvgTime+=dElapsedcpy;
    			} 
                dAvgTime=dAvgTime/iCpyLoopCount;
    			double dElapsedallcpy = TmePerofrmanceCount::EndTiming(lgStartallcpy);
    			dMemsetavg+=dElapsedallcpy;
                sssLog<<iSizeOrg<<","<<OneTest.iSize<<","<<dnewElapsed<<","<<dElapsed4k<<","<<dElapsedMemset<<","<<dMaxTime<<","<<dMinTime<<","<<dAvgTime<<","
                    <<dElapsedallcpy<<","<<dMemsetavg/(i+1)<<"\n";
    			delete [] pData;
    		}
    		delete [] pdataCpy;
    	}
    	catch (std::exception &e)
        {
    		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED);
    		std::cout<<e.what() <<std::endl;
    		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED |FOREGROUND_GREEN | FOREGROUND_BLUE);
    		throw;
    	}
    	RDMTestLog(sssLog.str(),filename);
    }
    bool GetParaFromXML(std::string strFilePath,std::string strParentElem,std::string& strValue)
    {
        CMarkup xmlDoc;
    	if (!xmlDoc.Load(strFilePath.c_str()))
    	{
    		return false;
    	} 
        if (xmlDoc.Load(strFilePath.c_str()))
        {
            xmlDoc.ResetMainPos();
            while (xmlDoc.FindChildElem(strParentElem.c_str()))
            {
                strValue=xmlDoc.GetChildData();
                break;
            }
            return true;
        }
    }
    void FindError(vector <vector <string>> vecAll_stock,int iColNum,double dThreshold,string sTestItem)
    {
        std::stringstream reportLog;
        string sTemp_size=vecAll_stock[1][0];
        bool bTemp_result=true;
        for (int i=1;i<vecAll_stock.size();i++)
        {
            if (0==strcmp(vecAll_stock[i][0].c_str(),sTemp_size.c_str()))
            {
                if (bTemp_result)
                {
                    if (atof(vecAll_stock[i][iColNum].c_str())>dThreshold)
                    {
                        reportLog<<sTestItem<<" timeout found! Temp size is "<<vecAll_stock[i][0]<<". Threshold  is "<<dThreshold<<"\n";
                        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED);
                        std::cout<<sTestItem<<" timeout found! Temp size is "<<vecAll_stock[i][0]<<". Threshold is "<<dThreshold<<"\n";
                        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED |FOREGROUND_GREEN | FOREGROUND_BLUE);
                        bTemp_result=false;
                        continue;
                    }
                }
            }
            else
            {
                sTemp_size=vecAll_stock[i][0];
                bTemp_result=true;
                i--;
            }
        }
        RDMTestLog(reportLog.str(),reportFilename);
    }
    void LogReport(double dNewThreshold,double d4KThreshold,double dMemsetThreshold,double dMemcpyThreshold)
    {
        int iItemSize=0;
        vector <vector <string>> All_stock;
        vector<string> stock_info;  
        string line_stock_info;  
        ifstream in_stock_info(filename);  
        if (in_stock_info.fail())  
        { 
            cout << "Open input file failed" <<endl; 
        }  
        while (getline(in_stock_info, line_stock_info)  && in_stock_info.good())
        {
            if (""==line_stock_info)
                continue;
            boost::split(stock_info,line_stock_info, boost::is_any_of(","));
            All_stock.push_back(stock_info);
        }
        FindError(All_stock,2,dNewThreshold,"New");
        FindError(All_stock,3,d4KThreshold,"4Kmemset");
        FindError(All_stock,4,dMemsetThreshold,"Memset");
        FindError(All_stock,8,dMemcpyThreshold,"Memcpy");
    
    }
    bool ctrlhandler( DWORD fdwctrltype ) 
    { 
        std::stringstream sssLog;
        switch( fdwctrltype ) 
        { 
            // handle the ctrl-c signal. 
        //case CTRL_C_EVENT: 
        //    printf( "ctrl-c event\n\n" );
        //    return( true );
    
            // ctrl-close: confirm that the user wants to exit. 
        case CTRL_CLOSE_EVENT: 
            LogReport(dNewThreshold,d4KThreshold,dMemsetThreshold,dMemcpyThreshold);
            sssLog<<"Test Interrupt!!\n";
            RDMTestLog(sssLog.str(),filename);
            return( true ); 
    
        //    // pass other signals to the next handler. 
        //case CTRL_BREAK_EVENT: 
        //    printf( "ctrl-break event\n\n" );
        //    return false; 
    
        //case CTRL_LOGOFF_EVENT: 
        //    printf( "ctrl-logoff event\n\n" );
        //    return false; 
    
        //case CTRL_SHUTDOWN_EVENT: 
        //    printf( "ctrl-shutdown event\n\n" );
        //    return false; 
    
        default: 
            return false; 
        } 
    } 
    class test
    {
    public:
        bool itest;
        int i;
    };
    int _tmain(int argc, _TCHAR* argv[])
    {
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN);
        std::cout<<"******************ReconWorkstationMemoryTest*******************\n";
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED |FOREGROUND_GREEN | FOREGROUND_BLUE);
    
        string strFilePath="MemoryTest.xml";
        string strALC;
        int64_t i1024 = 1024;
        time_t timep;
        time (&timep);
        strftime(filename, sizeof(filename), "MemoryAccessorLog%Y%m%d%H%M%S.csv",localtime(&timep) );
        strftime(reportFilename, sizeof(filename), "TestReport%Y%m%d%H%M%S.csv",localtime(&timep) );
        std::stringstream sssLog;
        std::stringstream reportLog;
    
        if( SetConsoleCtrlHandler( (PHANDLER_ROUTINE) ctrlhandler, true ) ) 
        { 
            sssLog<<"ALL_MemSize,OnePiece_MemSize,NEW_Time,4KMemset_Time,All0Memset_Time,OnePiece_Max_Time,OnePiece_Min_Time,OnePiece_Avg_Time,Memcpy_Time,Memcpy_Avg_Time\n";
            //SetProcessPriority();
    	    if(!GetParaFromXML(strFilePath,"AllLoopCount",strALC))
    	    {
    		    std::cout<<"xml file error!"<<"\n";
    		    std::cin.get();
    		    return 0;
    	    }
    	    else
    	    {
    		    iAllLoopCount=atoi(strALC.c_str());
    	    }
            if(!GetParaFromXML(strFilePath,"NewThreshold",strALC))
            {
                std::cout<<"xml file error!"<<"\n";
                std::cin.get();
                return 0;
            }
            else
            {
                dNewThreshold=atof(strALC.c_str());
            }
            if(!GetParaFromXML(strFilePath,"FourKThreshold",strALC))
            {
                std::cout<<"xml file error!"<<"\n";
                std::cin.get();
                return 0;
            }
            else
            {
                d4KThreshold=atof(strALC.c_str());
            }
            if(!GetParaFromXML(strFilePath,"MemsetThreshold",strALC))
            {
                std::cout<<"xml file error!"<<"\n";
                std::cin.get();
                return 0;
            }
            else
            {
                dMemsetThreshold=atof(strALC.c_str());
            }
            if(!GetParaFromXML(strFilePath,"MemcpyThreshold",strALC))
            {
                std::cout<<"xml file error!"<<"\n";
                std::cin.get();
                return 0;
            }
            else
            {
                dMemcpyThreshold=atof(strALC.c_str());
            }
            RDMTestLog(sssLog.str(),filename);
            std::cout<<"----The test loop count is "<<iAllLoopCount<<"\n";
    	    for(int i=0;i<iAllLoopCount;i++)
    	    {
                std::cout<<"Executing loop is "<<i+1<<"\n";
    		    CMarkup xml;
    		    if (!xml.Load(strFilePath.c_str()))
    		    {
    			    std::cout<<"xml file error!"<<"\n";
    		        std::cin.get();
    		        return 0;
    		    }
    		    xml.ResetPos();
    		    if (xml.FindElem())
    		    {
    			    xml.IntoElem();
    			    while(xml.FindElem())
    			    {
    				    if (strcmp(xml.GetTagName(),"List")==0)
    				    {
    					    xml.IntoElem();
    					    while (xml.FindElem())
    					    {
    						    struct TestItem OneTest;
                                int64_t itmp;
    						    OneTest.iAllLoopCount=iAllLoopCount;
    						    if (strcmp(xml.GetTagName(),"Item")==0)
    						    {
    							    string fieldname = xml.GetAttrib("name");
    							    if(atof(fieldname.c_str())<1&&atof(fieldname.c_str())*1000>1)
    							    {
    								    OneTest.iSize=i1024*atof(fieldname.c_str())*1000;
    							    }
    							    else
    								    OneTest.iSize=i1024*i1024*atof(fieldname.c_str());
    							    fieldname = xml.GetAttrib("type");
    							    OneTest.iInitType=fieldname=="1"?1:(fieldname=="2"? 2:0);
    							    fieldname = xml.GetAttrib("LoopCount");
    							    OneTest.iLoopCount=atoi(fieldname.c_str());
    							    fieldname = xml.GetAttrib("OrgMemory");
                                    OneTest.dOrgMem=atof(fieldname.c_str());
    						    }
                                try
                                {
                                    memcpytest(OneTest);	
                                    
                                }
                                catch(...)
                                {
                                    reportLog<<"An Exception occured in test Size:"<<OneTest.dOrgMem<<"G, Piece:"<<OneTest.iSize<<"byte, Type:"<<OneTest.iInitType<<"\n";
                                    continue;
                                }								
    					    }
    					    xml.OutOfElem();
    				    }
    			    }
    		    }
    	    }
            //find error info in log file
            LogReport(dNewThreshold,d4KThreshold,dMemsetThreshold,dMemcpyThreshold);
            cout << "ReconWorkstation Memory Test is Over!" <<endl; 
            return 0;  
          } 
    }  
    

    配置文件

    <?xml version="1.0" encoding="utf-8"?>
    <MemoryTest>
       <List name="TestList">
         <!--using 4k memset-->
    
    	 <Item name="0.01" type="1" LoopCount="10" OrgMemory="0.02"/>
    	 <Item name="0.02" type="1" LoopCount="10" OrgMemory="0.02"/>
    	 <Item name="0.05" type="1" LoopCount="10" OrgMemory="0.02"/>
    	 <Item name="0.1" type="1" LoopCount="10" OrgMemory="0.02"/>
    	 <Item name="0.15" type="1" LoopCount="10" OrgMemory="0.02"/>
    	 <Item name="0.2" type="1" LoopCount="10" OrgMemory="0.02"/>
    	 <Item name="0.3" type="1" LoopCount="10" OrgMemory="0.02"/>
    	 <Item name="0.5" type="1" LoopCount="10" OrgMemory="0.02"/>
    	 <Item name="0.8" type="1" LoopCount="10" OrgMemory="0.02"/>
    	 <Item name="1" type="1" LoopCount="10" OrgMemory="0.02"/>
    
    	
       </List>
       <AllLoopCount>1</AllLoopCount>
       <NewThreshold>0.01</NewThreshold>
       <FourKThreshold>100</FourKThreshold>
       <MemsetThreshold>200</MemsetThreshold>
       <MemcpyThreshold>1000</MemcpyThreshold>
    
    </MemoryTest>
    

    记录一下~

    展开全文
  • 默认情况下,这个脚本显示内存、CPU负荷内存使用情况。您可以可以去掉您不关心的项目。在终端里运行: gedit ~/.scripts/sysmon 在脚本开头的位置有下面的几个布尔值: #settings:  netspeed=...

    HOW TO DISPLAY NETWORK UPLOAD / DOWNLOAD SPEED ON THE PANEL IN UBUNTU 11.04


    Indicator sysmon

    Indicator-Sysmonitor (System Monitor Indicator) is a really interesting Ubuntu indicator because it allows you to display pretty much anything on the Unity (or GNOME) panel by using a simple command or a bash script.

    (Speaking of Indicator-Sysmonitor: a recent update brought sensors support (make sure you install hddtemp and lm-sensors), but this post isn't about that)

    Currently there is no AppIndicator to display the actual network usage as in the actual values on the Unity panel in Ubuntu 11.04. We have Indicator Multiload but it only displays a graph so I wrote a script for Indicator-Sysmonitor to display the network upload/download speed as well as CPU and Memory usage (Indicator Sysmonitor already has CPU and Memory usage but if you want to use a script, you must get your script to display the CPU and Memory usage independently).


    Update: I've replaced "up" and "down" in the AppIndicator with up/down arrows (thanks to manequin for the tip!) so this is how it looks now:

    System monitor indicator


    Getting Indicator-Sysmonitor to display network upload / download speed


    Before getting started, please note that while this worked just fine on my computer, 

    1. Firstly, install Indicator-Sysmonitor. For Ubuntu 11.04:
    sudo add-apt-repository ppa:alexeftimie/ppa
    sudo apt-get update
    sudo apt-get install indicator-sysmonitor

    If you use Ubuntu 10.10 (not working in Ubuntu 10.04!), download .deb from here.

    2. Install dstat (this is required by my script):
    sudo apt-get install dstat


    3. Now you must download the script. Let's create a folder (if it doesn't exists already) called "scripts" in your home directory and download the script there:
    mkdir -p ~/scripts && cd ~/scripts
    wget http://webupd8.googlecode.com/files/sysmon_0.2.tar.gz && tar -xvf sysmon_0.2.tar.gz

    4. Setting Up System Monitor Indicator to use the script.

    Now open Indicator-Sysmonitor (it should show up as System Monitor Indicator in the menu), then click it on the panel and select "Preferences" and under "Use this command", enter this:
    $HOME/scripts/sysmon

    Indicator Sysmon

    Then save. For me, each time I save the Indicator-Sysmon preferences, the applet freezes. If that's the case for you too, run this in a terminal:
    killall indicator-sysmonitor

    Then start it again.

    4. Configuring the script

    Indicator sysmon

    By default, the script displays the RAM and network usage. You can also display the CPU usage or any other combination (display the network usage only, display all: the CPU, ram and network, etc.). For this, open the script (run the following command in a terminal):
    gedit ~/scripts/sysmon

    And on top of the file you'll see something like this:
    #settings:
    netspeed=true
    ram=true
    cpu=false

    What these do is pretty much obvious - change the items you want to be displayed on the panel to true and the rest to false. Feel free to tweak the script to display other stuff if you want.


    在Ubuntu 11.10工具栏上用数字显示网速、CPU负荷和内存占用量『译』

    基本上照抄了《How To Display Network Upload / Download Speed On The Panel In Ubuntu 11.04》,只不过我的实践环境是Ubuntu 11.10而已。

    indicator-sysmonitor是一个能在Unity的工具栏上用数字显示系统状况的实用工具。如上图。一般装完以后只能显示CPU和内存,无法显示网速。Andrew 写了个脚本解决这个问题。

    由于比较懒,没有完整翻译原文。只把必要的写下来了。


    在开始之前先声明一下,以下所有步骤在我的电脑上都运行的很好。

    1. 首先在Ubuntu 11.10上安装 Indicator-Sysmonitor。

    sudo add-apt-repository ppa:alexeftimie/ppa 
    sudo apt-get update 
    sudo apt-get install indicator-sysmonitor


    2. 安装 dstat (运行定制脚本必备):

    sudo apt-get install dstat

    3. 下载 Andrew 编写的脚本

    下面我们在主文件夹里面创建一个 “.scripts” 文件夹,并把脚本下载到这个文件夹内:

    mkdir -p ~/.scripts && cd ~/.scripts

    wget http://webupd8.googlecode.com/files/sysmon_0.2.tar.gz && tar -xvf sysmon_0.2.tar.gz

    4. 设置System Monitor,让它使用脚本里的配置。
    下面 Alt+F2 运行indicator-sysmonitor。在工具栏点击Indicator-Sysmonitor 并选择 "Preferences" ,并在 "Use this command" 里输入:

    $HOME/.scripts/sysmon

    勾选“Run on startup” 后保存退出。在我机器上运行的时候,经常在修改配置的过程中 Indicator-Sysmon 会僵死。如果发生了这种情况请在终端用这个命令杀死任务:

    killall indicator-sysmonitor

    然后重新运行它。

    4. 自行配置脚本


     

    默认情况下,这个脚本显示内存、CPU负荷、内存使用情况。您可以可以去掉您不关心的项目。在终端里运行:

    gedit ~/.scripts/sysmon

    在脚本开头的位置有下面的几个布尔值:

    #settings: 
    netspeed=true 
    ram=true 
    cpu=true


     总之您自己看着改吧。也可以鼓捣这个脚本显示点别的东西。


    顺便再提供两个很有用的插件:

    Touchpad Indicator —— 这个插件可以轻松控制触控板状态(启用/禁用),并可在插入鼠标时自动禁用触控板。支持快捷键启用/禁用。

    sudo add-apt-repository ppa:atareao/atareao
    sudo apt-get update
    sudo apt-get install touchpad-indicator


    ClassicMenu Indicator —— 这个插件为 Unity 提供了类似 GNOME 风格的应用程序菜单

    sudo add-apt-repository ppa:diesch/testing
    sudo apt-get update
    sudo apt-get install classicmenu-indicator

    以上两段感谢笨兔兔分享

    --------------------------------------

    『Over』


    展开全文
  • for j in {1..3};do echo -ne "10.168.101.3$j"; for i in {0..6}; do cat `date -d "-$i day" +%Y%m%d`/bcec_sys* | grep 192.168.101.3$j -A 8 | grep load ;done | awk '{sum+=$4} END {print " o(*╯3╰)o lo...
  • ----------------------------我是分割线------------------------------- ...在这一点后,内存中OLTP工作负荷继续几乎呈线性的扩展,而基于磁盘的工作负荷则达到大规模的一个障碍。 图7从AdventureWorks示例...
  • 这些数据仓库类型的工作负荷可能会受益于像数据仓库的内存中列存储这样的解决方案。当涉及到内存优化表时,无论是这种索引还是并行执行计划都不能被使用。在这些情况下,在一段时间后将这些数据迁移到基于磁盘的表中...
  • 微软设计了内存中OLTP来处理要求最苛刻的OLTP工作负荷。为了实现这一点,内存中OLTP引入了两个全新的概念:内存优化表和本地编译的存储过程。内存优化表中的数据驻留在内存中,同时为了恢复,事务被记录在日志中,...
  • 基本上照抄了《How To Display Network Upload / Download Speed On The Panel In Ubuntu 11.04》,只不过我的实践环境是Ubuntu 11.10而已。...一般装完以后只能显示CPU和内存,无法显示网速。Andrew ...
  • 平均值: cat 192.168.101.* | grep load | awk '{sum+=$4} END {print "average=", sum/NR}' cat 192.168.101.* | grep Memory | awk '{sum+=$3} END {print "average=", sum/NR}' cat 192.168.101.* | grep os....
  • tomcat cpu负荷

    2016-03-30 10:53:02
    我们在用zabbix监控tomcat时,发现tomcat的cpu负荷。第一步,我们直接在内存池里面加没内存,方法如下:1 在你的tomcat的bin目录下,找到,擦catalina.sh直接添加以行代码JAVA_OPTS='-server-Xms1024m-Xmx1024m-XX:...
  • 1系统负荷

    2017-10-30 21:16:00
    1分钟,5分钟,15分钟内系统的平均负荷, 单核CPU 0.7左右需要注意了 多核的除以核心数小于0.7就可以 查看核数:grep -c 'model name' /proc/cpuinfo uptime 21:21:13 up 38 days, 28 min, 1 user, load ...
  • 业务负荷管理实现

    2015-09-19 10:23:17
    业务需要实时监控cpu、内存、TCP连接和数据库连接数,供发生问题时回溯日志,并在超过某负荷时拒绝服务并发出告警 实现 1.监控部分,使用sigar,主要包括CPU信息、TCP连接、内存等,参考Sigar;数据库部分使用...
  • 其实以上问题都是虚拟内存设置问题造成的,我一开始也想到虚拟内存,但设置后没有运行高负荷,感觉设置前后没有什么区别而错过了机会绕了弯路。 如何设置虚拟内存呢,按照网上老掉牙的方法:物理内存1
  • 默认情况下,这个脚本显示内存、CPU负荷内存使用情况。您可以可以去掉您不关心的项目。在终端里运行: gedit ~/.scripts/sysmon 在脚本开头的位置有下面的几个布尔值: #settings:  ...
  • 如果内存占用率高,无法满足我们想要的电脑运行负荷,和想要的电脑操作体验,那么可以选择升级内存。【看电压】在AIDA64找到SPD信息,在里面可以看到内存条的模块电压。在选择笔记本DDR3内存条时,我们需要先了解...
  • 免费扩大电脑内存

    2019-08-26 10:14:26
    日常工作中,需要进行大量的本地计算,导致系统内存负荷运行进而导致电脑卡顿,非常影响工作效率。通过设置虚拟内存可以实现目的。 在已经设置好的电脑里,任务管理器中查看到 可用内存20 GB*=物理内存8 GB+虚拟...
  • 当实例完成初始化后,就不会再获取更多的内存,直到用户连接到该实例并开始产生工作负荷。该实例根据需要不停地获取内存以支持工作负荷。随着更多的用户连接并运行查询,SQL Server将获取支持需求所需的额外内存
  • JVM调优工具Jconsole,jProfile,VisualVMJconsole :jdk自带,功能简单,但是可以在系统有一定负荷的情况下使用。对垃圾回收算法有很详细的跟踪。详细说明参考这里JProfiler:商业软件,需要付费。功能强大。详细...
  • 内存泄露检查

    2016-10-10 10:54:00
    内存泄漏是比较常见的问题,而且解决方法也比较通用,这里可以重点说一下,而线程、热点方面的问题则是具体问题具体分析了。 内存泄漏一般可以理解为系统...需要区别一下,内存泄漏和系统超负荷两者是有区别的,虽...
  • 当实例完成初始化后,就不会再获取更多的内存,直到用户连接到该实例并开始产生工作负荷。这 时,该实例根据需要不停地获取内存以支持工作负荷。随着更多的用户连接并运行查询,SQL Server 将获取支持需求所需的额外...
  • 通过引入Spark on YARN内存计算平台,将改进并行粒子群优化(IPPSO)算法部署在平台上,对最小二乘支持向量机(LSSVM)的不确定参数进行算法优化,利用优化后的参数进行负荷预测。通过引入并行化和分布式的...
  • 应用内存测试分析

    2018-03-19 22:53:00
    抛砖引玉,旨在描述和指导如何在android上测试与分析app的内存情况 术语释义 空负荷:app已经在后台运行,但是用户没有使用; 中负荷:app在前台运行,用户进行了少量操作; 满负荷:用户持续频繁大量操作,app接近...
  • Microsoft SQL Server 2000 的内存管理组件消除了对 SQL Server 可用的内存进行手工管理的需要...当计算机和SQL Server 上的负荷更改时,分配的内存也随之更改。本文将为大家介绍通过内存配置来优化SQL Server的性能。
  • 内存利用率

    2012-05-05 22:59:00
    内存利用率 有多个命令提供有关系统内存利用率的相关信息。最流行的是free 和pmap。 free命令 free 命令显示可用...图7-5 显示了在中等负荷的操作系统上运行free 命令的一个例子。 图7-5:free命令 图7-5 是来自于Ub...
  • APP性能测试--内存测试

    千次阅读 2018-03-24 16:31:00
    一、内存占用对于智能手机而言,内存大小是固定的;因此,如果单个app的内存占用越小,手机上可以安装运行的app就越多;或者说app的内存占用越小,在手机上运行就会越流畅。所以说,内存占用的大小,也是考量app性能...
  • APP性能指标之内存

    2019-02-19 22:44:00
    1.测试app内存占用的方法: adb shell dumpsys meminfo <包名>or pid 2.原理说明 对于一个app,我们可以关注它在3种状态下的内存占用情况: 空负荷————app已经在后台运行,但是用户没有使用; 中负荷...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,036
精华内容 414
关键字:

内存负荷