C++ SCXHandle::GetUsedMemory方法代码示例

    /**
        Get the value for the spcified resource from a specified instance

        \param[in]     resource      Name of resource to get
        \param[in]     processinst   Instance to get resource from

        \returns       Value for specifed resource

        \throws        SCXInternalErrorException    If given resource not handled
    */
    scxulong ProcessProvider::GetResource(const std::wstring &resource, SCXCoreLib::SCXHandle<SCXSystemLib::ProcessInstance> processinst)
    {
        scxulong res = 0;
        bool gotResource = false;

        if (StrCompare(resource, L"CPUTime", true) == 0)
        {
            unsigned int cputime;
            gotResource = processinst->GetCPUTime(cputime);
            res = static_cast<scxulong>(cputime);
        }
        else if (StrCompare(resource, L"BlockReadsPerSecond", true) == 0)
        {
            gotResource = processinst->GetBlockReadsPerSecond(res);
        }
        else if (StrCompare(resource, L"BlockWritesPerSecond", true) == 0)
        {
            gotResource = processinst->GetBlockWritesPerSecond(res);
        }
        else if (StrCompare(resource, L"BlockTransfersPerSecond", true) == 0)
        {
            gotResource = processinst->GetBlockTransfersPerSecond(res);
        }
        else if (StrCompare(resource, L"PercentUserTime", true) == 0)
        {
            gotResource = processinst->GetPercentUserTime(res);
        }
        else if (StrCompare(resource, L"PercentPrivilegedTime", true) == 0)
        {
            gotResource = processinst->GetPercentPrivilegedTime(res);
        }
        else if (StrCompare(resource, L"UsedMemory", true) == 0)
        {
            gotResource = processinst->GetUsedMemory(res);
        }
        else if (StrCompare(resource, L"PercentUsedMemory", true) == 0)
        {
            gotResource = processinst->GetPercentUsedMemory(res);
        }
        else if (StrCompare(resource, L"PagesReadPerSec", true) == 0)
        {
            gotResource = processinst->GetPagesReadPerSec(res);
        }
        else
        {
            throw UnknownResourceException(resource, SCXSRCLOCATION);
        }

        if ( ! gotResource)
        {
            throw SCXInternalErrorException(StrAppend(L"GetResource: Failed to get resouce: ", resource), SCXSRCLOCATION);
        }

        return res;
    }

MI_BEGIN_NAMESPACE

static void EnumerateOneInstance(
    Context& context,
    SCX_MemoryStatisticalInformation_Class& inst,
    bool keysOnly,
    SCXCoreLib::SCXHandle<SCXSystemLib::MemoryInstance> meminst)
{
    // Populate the key values
    inst.Name_value("Memory");

    if (!keysOnly)
    {
        scxulong physmem = 0;
        scxulong resmem = 0;
        scxulong usermem = 0;
        scxulong avail = 0;
        scxulong data = 0;
        scxulong data2 = 0;

        inst.Caption_value("Memory information");
        inst.Description_value("Memory usage and performance statistics");

        inst.IsAggregate_value(meminst->IsTotal());

        if (meminst->GetTotalPhysicalMemory(physmem))
        {
            // Adjust numbers from PAL to Megabytes
            physmem = BytesToMegaBytes(physmem);

            if (meminst->GetReservedMemory(resmem))
            {
                resmem = BytesToMegaBytes(resmem);
            }
            else
            {
                resmem = 0;
            }

            // If available, get memory unavailable for user processes and remove it from physical memory
            usermem = physmem - resmem;
        }

        if (meminst->GetAvailableMemory(avail))
        {
            // Adjust numbers from PAL to Megabytes
            avail = BytesToMegaBytes(avail);
            inst.AvailableMemory_value(avail);

            // If we have a number for physical memory use it to compute a percentage
            if (usermem > 0)
            {
                // Need an unsigned char since this is what is required by the MOF
                unsigned char percent = static_cast<unsigned char> (GetPercentage(0, avail, 0, usermem));
                inst.PercentAvailableMemory_value(percent);
            }
        }

        if (meminst->GetUsedMemory(data))
        {
            // Adjust numbers from PAL to Megabytes
            data = BytesToMegaBytes(data);
            inst.UsedMemory_value(data);

            // If we have a number for physical memory use it to compute a percentage
            if (usermem > 0)
            {
                unsigned char percent = static_cast<unsigned char> (GetPercentage(0, data, 0, usermem));
                inst.PercentUsedMemory_value(percent);
            }
        }

        {
            data = 0;
            unsigned char percent = static_cast<unsigned char> (0);

            if (meminst->GetCacheSize(data) && usermem > 0)
            {
                percent = static_cast<unsigned char> (GetPercentage(0, BytesToMegaBytes(data), 0, usermem));
            }
            inst.PercentUsedByCache_value(percent);
        }

        bool pageReadsAvailable = meminst->GetPageReads(data);
        bool pageWritesAvailable = meminst->GetPageWrites(data2);
        if (pageReadsAvailable && pageWritesAvailable)
        {
            inst.PagesPerSec_value(data + data2);
        }

        if (pageReadsAvailable)
        {
            inst.PagesReadPerSec_value(data);
        }

        if (pageWritesAvailable)
        {
            inst.PagesWrittenPerSec_value(data2);
        }

//.........这里部分代码省略.........

//.........这里部分代码省略.........
                inst.AddProperty(prop);
            }

            if (processinst->GetBlockWritesPerSecond(ulong))
            {
                SCXProperty prop(L"BlockWritesPerSecond", ulong);
                inst.AddProperty(prop);
            }

            if (processinst->GetBlockReadsPerSecond(ulong))
            {
                SCXProperty prop(L"BlockReadsPerSecond", ulong);
                inst.AddProperty(prop);
            }

            if (processinst->GetBlockTransfersPerSecond(ulong))
            {
                SCXProperty prop(L"BlockTransfersPerSecond", ulong);
                inst.AddProperty(prop);
            }

            if (processinst->GetPercentUserTime(ulong))
            {
                SCXProperty prop(L"PercentUserTime", (unsigned char) ulong);
                inst.AddProperty(prop);
            }

            if (processinst->GetPercentPrivilegedTime(ulong))
            {
                SCXProperty prop(L"PercentPrivilegedTime", (unsigned char) ulong);
                inst.AddProperty(prop);
            }

            if (processinst->GetUsedMemory(ulong))
            {
                SCXProperty prop(L"UsedMemory", ulong);
                inst.AddProperty(prop);
            }

            if (processinst->GetPercentUsedMemory(ulong))
            {
                SCXProperty prop(L"PercentUsedMemory", (unsigned char) ulong);
                inst.AddProperty(prop);
            }

            if (processinst->GetPagesReadPerSec(ulong))
            {
                SCXProperty prop(L"PagesReadPerSec", ulong);
                inst.AddProperty(prop);
            }
        }
        else if (eSCX_UnixProcess == cimtype)
        {
            std::string name("");
            std::vector<std::string> params;
            std::wstring str(L"");
            unsigned int uint = 0;
            unsigned short ushort = 0;
            scxulong ulong = 0;
            SCXCoreLib::SCXCalendarTime ctime;
            int pid = 0;

            if (processinst->GetOtherExecutionDescription(str))
            {
                SCXProperty prop(L"OtherExecutionDescription", str);
                inst.AddProperty(prop);

//.........这里部分代码省略.........
        inst.Description_value("A snapshot of a current process");
        inst.Caption_value("Unix process information");

        if (processinst->GetRealData(ulong))
        {
            inst.RealData_value(ulong);
        }

        if (processinst->GetRealStack(ulong))
        {
            inst.RealStack_value(ulong);
        }

        if (processinst->GetVirtualText(ulong))
        {
            inst.VirtualText_value(ulong);
        }

        if (processinst->GetVirtualData(ulong))
        {
            inst.VirtualData_value(ulong);
        }

        if (processinst->GetVirtualStack(ulong))
        {
            inst.VirtualStack_value(ulong);
        }

        if (processinst->GetVirtualMemoryMappedFileSize(ulong))
        {
            inst.VirtualMemoryMappedFileSize_value(ulong);
        }

        if (processinst->GetVirtualSharedMemory(ulong))
        {
            inst.VirtualSharedMemory_value(ulong);
        }

        if (processinst->GetCpuTimeDeadChildren(ulong))
        {
            inst.CpuTimeDeadChildren_value(ulong);
        }

        if (processinst->GetSystemTimeDeadChildren(ulong))
        {
            inst.SystemTimeDeadChildren_value(ulong);
        }

        if (processinst->GetRealText(ulong))
        {
            inst.RealText_value(ulong);
        }

        if (processinst->GetCPUTime(uint))
        {
            inst.CPUTime_value(uint);
        }

        if (processinst->GetBlockWritesPerSecond(ulong))
        {
            inst.BlockWritesPerSecond_value(ulong);
        }

        if (processinst->GetBlockReadsPerSecond(ulong))
        {
            inst.BlockReadsPerSecond_value(ulong);
        }

        if (processinst->GetBlockTransfersPerSecond(ulong))
        {
            inst.BlockTransfersPerSecond_value(ulong);
        }

        if (processinst->GetPercentUserTime(ulong))
        {
            inst.PercentUserTime_value((unsigned char) ulong);
        }

        if (processinst->GetPercentPrivilegedTime(ulong))
        {
            inst.PercentPrivilegedTime_value((unsigned char) ulong);
        }

        if (processinst->GetUsedMemory(ulong))
        {
            inst.UsedMemory_value(ulong);
        }

        if (processinst->GetPercentUsedMemory(ulong))
        {
            inst.PercentUsedMemory_value((unsigned char) ulong);
        }

        if (processinst->GetPagesReadPerSec(ulong))
        {
            inst.PagesReadPerSec_value(ulong);
        }
    }
    context.Post(inst);
}