Tool之MemScope

Taishan3721

发布于 2021-11-12 18:32:32

3470

发布于 2021-11-12 18:32:32

文章被收录于专栏：这里只有VxWorks这里只有VxWorks

WindRiver在2005年收购了一套叫做ScopeTools的软件。其中包含一个MemScope，不过从Vx67开始，改名为Memroy Analyzer

这个工具能干什么

查找内存泄漏。在它的Aggregate视图里，可以看到未释放的内存，这些就有可能存在内存泄漏
查看每个程序的内存使用情况。在Tree视图里，动态显示每个程序使用的内存数量及分配位置
显示动态内存分配。在Time视图里，以图形方式查看内存的分配和释放
查看内存使用效率。通过call stack查看Heap的使用情况，用于判断内存的占用情况和使用效率

随便跑个例子，就知道它怎么用了，例如这个代码，加到VxWorks 6里

#include <stdLib.h>
#include <taskLib.h>

#define BLOCK_SZ (1024)

void testMemScope()
{
    char *mem_ptr[10];
    int allocated[10] = {0};

    for(;;)
        {
        switch(rand()%10)
            {
            case 0:
                if(allocated[0] == 0)
                    {
                    mem_ptr[0] = (char *)malloc(1*BLOCK_SZ);
                    allocated[0] = 1;
                    }
                else
                    {
                    free((void *)mem_ptr[0]);
                    allocated[0]=0;
                    }
                break;

            case 1:
                if(allocated[1] == 0)
                    {
                    mem_ptr[1] = (char *)malloc(2*BLOCK_SZ);
                    allocated[1] = 1;
                    }
                else
                    {
                    free((void *)mem_ptr[1]);
                    allocated[1]=0;
                    }
                break;

            case 2:
                if(allocated[2] == 0)
                    {
                    mem_ptr[2] = (char *)malloc(3*BLOCK_SZ);
                    allocated[2] = 1;
                    }
                else
                    {
                    free((void *)mem_ptr[2]);
                    allocated[2]=0;
                    }
                break;

            case 3:
                if(allocated[3] == 0)
                    {
                    mem_ptr[3] = (char *)malloc(4*BLOCK_SZ);
                    allocated[3] = 1;
                    }
                else
                    {
                    free((void *)mem_ptr[3]);
                    allocated[3]=0;
                    }
                break;

            case 4:
                if(allocated[4] == 0)
                    {
                    mem_ptr[4] = (char *)malloc(5*BLOCK_SZ);
                    allocated[4] = 1;
                    }
                else
                    {
                    free((void *)mem_ptr[4]);
                    allocated[4]=0;
                    }
                break;

            case 5:
                if(allocated[5] == 0)
                    {
                    mem_ptr[5] = (char *)malloc(6*BLOCK_SZ);
                    allocated[5] = 1;
                    }
                else
                    {
                    free((void *)mem_ptr[5]);
                    allocated[5]=0;
                    }
                break;

            case 6:
                if(allocated[6] == 0)
                    {
                    mem_ptr[6] = (char *)malloc(7*BLOCK_SZ);
                    allocated[6] = 1;
                    }
                else
                    {
                    free((void *)mem_ptr[6]);
                    allocated[6]=0;
                    }
                break;

            case 7:
                if(allocated[7] == 0)
                    {
                    mem_ptr[7] = (char *)malloc(8*BLOCK_SZ);
                    allocated[7] = 1;
                    }
                else
                    {
                    free((void *)mem_ptr[7]);
                    allocated[7]=0;
                    }
                break;

            case 8:
                if(allocated[8] == 0)
                    {
                    mem_ptr[8] = (char *)malloc(9*BLOCK_SZ);
                    allocated[8] = 1;
                    }
                else
                    {
                    free((void *)mem_ptr[8]);
                    allocated[8]=0;
                    }
                break;

            case 9:
                if(allocated[9] == 0)
                    {
                    mem_ptr[9] = (char *)malloc(10*BLOCK_SZ);
                    allocated[9] = 1;
                    }
                else
                    {
                    free((void *)mem_ptr[9]);
                    allocated[9]=0;
                    }
                break;

            default:
                break;
            }
        taskDelay(60);
        }
    }

代码很简单，启动VxWorks 6后，在WorkBench里已连接的Target Connection上右击，选择Attach Memory Analyzer