void PrintMemInfo(int id){
LPBYTE currAddress = 0;
PSAPI_WORKING_SET_INFORMATION wsi;
PSAPI_WORKING_SET_BLOCK* wsb;
PERFORMANCE_INFORMATION pi;
MEMORYSTATUSEX ms;
PROCESS_MEMORY_COUNTERS pmc;
PROCESS_MEMORY_COUNTERS_EX pmcex;
DWORD countPrivatePages = 0;
MEMORY_BASIC_INFORMATION mbi;
LPBYTE regionNonFree = 0;
ms.dwLength = sizeof (ms);
_tprintf(_T("Informacao do sistema\n"));
GetPerformanceInfo(&pi , sizeof(PERFORMANCE_INFORMATION));
_tprintf(_T("\nTotal Memoria existente fisica em paginas->%d\n"),pi.PhysicalTotal);
_tprintf(_T("Total Memoria ocupada fisica em paginas->%d\n"), (pi.PhysicalTotal - pi.PhysicalAvailable));
GlobalMemoryStatusEx(&ms);
_tprintf(_T("Total Memoria existente virtual em kb->%d\n"),ms.ullTotalPageFile / 1024);
_tprintf(_T("Total Memoria ocupada virtual em kb->%d\n"),(ms.ullTotalPageFile - ms.ullAvailVirtual) / 1024);
_tprintf(_T("\nInformacao do processo\n"));
HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, id );
if(!hProcess)
return ;
QueryWorkingSet(hProcess,&wsi,sizeof(wsi));
wsb = wsi.WorkingSetInfo;
_tprintf(_T("Dimensão do working set ->%d\n"),sizeof(wsb)*wsi.NumberOfEntries);
GetProcessMemoryInfo( hProcess, &pmc, sizeof(pmc));
_tprintf(_T("Page fault count ->%d\n"),pmc.PageFaultCount);
while (VirtualQueryEx( hProcess, currAddress, &mbi, sizeof(mbi)) > 0) {
if (mbi.State != MEM_FREE)
regionNonFree += mbi.RegionSize;
currAddress += mbi.RegionSize;
}
_tprintf(_T("Total de espaço de endereçamento existente->%d\n"),currAddress-hProcess);
_tprintf(_T("Total de espaço de endereçamento ocupado ->%d\n"),regionNonFree);
for(int i = 0 ; i<sizeof(wsi) ; ++i){
if(!(wsb+i)->Shared){
countPrivatePages++;
}
}
_tprintf(_T("Total de private pages->%d\n"),countPrivatePages);
}
void CWorkingSetMonitor::SampleWorkingSets()
{
CSingleLock locker(&processesLock_);
if (processes_.empty() && !processAll_)
return;
// CreateToolhelp32Snapshot runs faster than EnumProcesses and
// it returns the process name as well, thus avoiding a call to
// EnumProcessModules to get the name.
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, TH32CS_SNAPPROCESS);
if (!hSnapshot)
return;
PROCESSENTRY32W peInfo;
peInfo.dwSize = sizeof(peInfo);
BOOL nextProcess = Process32First(hSnapshot, &peInfo);
// Allocate enough space to get the working set of most processes.
// It will grow if needed.
ULONG_PTR numEntries = 100000;
const rsize_t bufferSizeNeeded =
sizeof(PSAPI_WORKING_SET_INFORMATION) +
(numEntries * sizeof(PSAPI_WORKING_SET_BLOCK));
std::vector<char> buffer(bufferSizeNeeded);
PSAPI_WORKING_SET_INFORMATION* pwsBuffer = reinterpret_cast<PSAPI_WORKING_SET_INFORMATION*>(buffer.data());
ULONG_PTR totalWSPages = 0;
// The PSS page count is stored as a multiple of PSSMultiplier.
// This allows all the supported share counts, from 1 to 7, to be
// divided out without loss of precision. That is, an unshared page
// is recorded by adding 420. A page shared by seven processes (the
// maximum recorded) is recorded by adding 420/7.
const uint64_t PSSMultiplier = 420; // LCM of 1, 2, 3, 4, 5, 6, 7
uint64_t totalPSSPages = 0;
ULONG_PTR totalPrivateWSPages = 0;
// Iterate through the processes.
while (nextProcess)
{
bool match = processAll_;
for (const auto& name : processes_)
{
if (_wcsicmp(peInfo.szExeFile, name.c_str()) == 0)
{
match = true;
}
}
if (match)
{
DWORD pid = peInfo.th32ProcessID;
// Get a handle to the process.
HANDLE hProcess =
OpenProcess(PROCESS_QUERY_INFORMATION |
PROCESS_VM_READ, FALSE, pid);
ULONG_PTR wsPages = 0;
uint64_t PSSPages = 0;
ULONG_PTR privateWSPages = 0;
if (NULL != hProcess)
{
bool success = true;
if (bExpensiveWSMonitoring_)
{
if (!QueryWorkingSet(hProcess, &buffer[0], static_cast<DWORD>(buffer.size())))
{
success = false;
// Increase the buffer size based on the NumberOfEntries returned,
// with some padding in case the working set is increasing.
if (GetLastError() == ERROR_BAD_LENGTH)
{
numEntries = pwsBuffer->NumberOfEntries + pwsBuffer->NumberOfEntries / 4;
buffer.resize(sizeof(PSAPI_WORKING_SET_INFORMATION) + numEntries * sizeof(PSAPI_WORKING_SET_BLOCK));
pwsBuffer = reinterpret_cast<PSAPI_WORKING_SET_INFORMATION*>(&buffer[0]);
if (QueryWorkingSet(hProcess, &buffer[0], static_cast<DWORD>(buffer.size())))
{
success = true;
}
}
}
if (success)
{
wsPages = pwsBuffer->NumberOfEntries;
for (ULONG_PTR page = 0; page < wsPages; ++page)
{
if (!pwsBuffer->WorkingSetInfo[page].Shared)
{
++privateWSPages;
PSSPages += PSSMultiplier;
}
else
{
UIETWASSERT(pwsBuffer->WorkingSetInfo[page].ShareCount <= 7);
PSSPages += PSSMultiplier / pwsBuffer->WorkingSetInfo[page].ShareCount;
}
}
totalPSSPages += PSSPages;
totalPrivateWSPages += privateWSPages;
}
}
else
{
PROCESS_MEMORY_COUNTERS memoryCounters = {sizeof(memoryCounters)};
if (GetProcessMemoryInfo(hProcess, &memoryCounters, sizeof(memoryCounters)))
{
wsPages = memoryCounters.WorkingSetSize / 4096;
}
}
if (success)
{
totalWSPages += wsPages;
wchar_t process[MAX_PATH + 100];
swprintf_s(process, L"%s (%u)", peInfo.szExeFile, pid);
ETWMarkWorkingSet(peInfo.szExeFile, process, counter_, static_cast<unsigned>(privateWSPages * 4), static_cast<unsigned>((PSSPages * 4) / PSSMultiplier), static_cast<unsigned>((wsPages * 4)));
}
CloseHandle(hProcess);
}
}
nextProcess = Process32Next(hSnapshot, &peInfo);
}
CloseHandle(hSnapshot);
ETWMarkWorkingSet(L"Total", L"", counter_, static_cast<unsigned>(totalPrivateWSPages * 4), static_cast<unsigned>((totalPSSPages * 4) / PSSMultiplier), static_cast<unsigned>(totalWSPages * 4));
++counter_;
}
NTSTATUS PHAPI PhQueryProcessWs(
HANDLE ProcessHandle,
WS_INFORMATION_CLASS WsInformationClass,
PVOID WsInformation,
ULONG WsInformationLength,
PULONG ReturnLength
)
{
switch (WsInformationClass)
{
case WsCount:
case WsPrivateCount:
case WsSharedCount:
case WsShareableCount:
if (WsInformationLength < 4)
return STATUS_BUFFER_TOO_SMALL;
goto WsCounters;
case WsAllCounts:
if (WsInformationLength < sizeof(WS_ALL_COUNTS))
return STATUS_BUFFER_TOO_SMALL;
WsCounters:
{
PROCESS_MEMORY_COUNTERS procMem;
ULONG count = 0;
ULONG privateCount = 0;
ULONG sharedCount = 0;
ULONG shareableCount = 0;
PPSAPI_WORKING_SET_INFORMATION wsInfo;
SIZE_T wsInfoLength;
ULONG i;
if (!GetProcessMemoryInfo(ProcessHandle, &procMem, sizeof(procMem)))
return STATUS_UNSUCCESSFUL;
/* Assume the page size is 4kB */
wsInfoLength = sizeof(PSAPI_WORKING_SET_INFORMATION) +
sizeof(PSAPI_WORKING_SET_BLOCK) * (procMem.WorkingSetSize / 4096);
wsInfo = (PPSAPI_WORKING_SET_INFORMATION)PhAlloc(wsInfoLength);
if (!QueryWorkingSet(ProcessHandle, wsInfo, wsInfoLength))
{
PhFree(wsInfo);
return STATUS_UNSUCCESSFUL;
}
for (i = 0; i < wsInfo->NumberOfEntries; i++)
{
PSAPI_WORKING_SET_BLOCK block = wsInfo->WorkingSetInfo[i];
count++;
if (block.ShareCount > 1)
sharedCount++;
if (block.ShareCount == 0)
privateCount++;
if (block.Shared)
shareableCount++;
}
PhFree(wsInfo);
switch (WsInformationClass)
{
case WsCount:
*(PULONG)WsInformation = count;
break;
case WsPrivateCount:
*(PULONG)WsInformation = privateCount;
break;
case WsSharedCount:
*(PULONG)WsInformation = sharedCount;
break;
case WsShareableCount:
*(PULONG)WsInformation = shareableCount;
break;
case WsAllCounts:
{
PWS_ALL_COUNTS allCounts = (PWS_ALL_COUNTS)WsInformation;
allCounts->Count = count;
allCounts->PrivateCount = privateCount;
allCounts->SharedCount = sharedCount;
allCounts->ShareableCount = shareableCount;
break;
}
}
return STATUS_SUCCESS;
}
break;
default:
return STATUS_INVALID_PARAMETER;
}
}
bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const {
size_t ws_private = 0;
size_t ws_shareable = 0;
size_t ws_shared = 0;
DCHECK(ws_usage);
memset(ws_usage, 0, sizeof(*ws_usage));
DWORD number_of_entries = 4096; // Just a guess.
PSAPI_WORKING_SET_INFORMATION* buffer = NULL;
int retries = 5;
for (;;) {
DWORD buffer_size = sizeof(PSAPI_WORKING_SET_INFORMATION) +
(number_of_entries * sizeof(PSAPI_WORKING_SET_BLOCK));
// if we can't expand the buffer, don't leak the previous
// contents or pass a NULL pointer to QueryWorkingSet
PSAPI_WORKING_SET_INFORMATION* new_buffer =
reinterpret_cast<PSAPI_WORKING_SET_INFORMATION*>(
realloc(buffer, buffer_size));
if (!new_buffer) {
free(buffer);
return false;
}
buffer = new_buffer;
// Call the function once to get number of items
if (QueryWorkingSet(process_, buffer, buffer_size))
break; // Success
if (GetLastError() != ERROR_BAD_LENGTH) {
free(buffer);
return false;
}
number_of_entries = static_cast<DWORD>(buffer->NumberOfEntries);
// Maybe some entries are being added right now. Increase the buffer to
// take that into account.
number_of_entries = static_cast<DWORD>(number_of_entries * 1.25);
if (--retries == 0) {
free(buffer); // If we're looping, eventually fail.
return false;
}
}
// On windows 2000 the function returns 1 even when the buffer is too small.
// The number of entries that we are going to parse is the minimum between the
// size we allocated and the real number of entries.
number_of_entries =
std::min(number_of_entries, static_cast<DWORD>(buffer->NumberOfEntries));
for (unsigned int i = 0; i < number_of_entries; i++) {
if (buffer->WorkingSetInfo[i].Shared) {
ws_shareable++;
if (buffer->WorkingSetInfo[i].ShareCount > 1)
ws_shared++;
}
else {
ws_private++;
}
}
ws_usage->priv = ws_private * PAGESIZE_KB;
ws_usage->shareable = ws_shareable * PAGESIZE_KB;
ws_usage->shared = ws_shared * PAGESIZE_KB;
free(buffer);
return true;
}
/**
* @brief
* Internal session memory usage decoding routine.
* Accepts a job pointer. Returns the sum of all memory
* consumed for all tasks executed by the job, in kilo bytes.
*
* NOTE: To retrieve a handle to any process in the system,
* the calling process should have a privilege "SeDebugPrivilege".
* A Win32 API OpenProcess() can be used in a calling process
* to obtain any desired process handle in the system.
*
* In PBS, ena_privilege() function can be used to enable
* SeDebugPrivilege for calling process. For pbs_mom process,
* ena_privilege() has been used in it's main_thread() function.
*
* @param[in] pjob - pointer to job
*
* @return u_Long
* @retval 0 - failure
* @retval memory usage of all the processes of a job - failure
*/
static u_Long
mem_sum(job *pjob)
{
u_Long mem = 0;
int nps = 0;
DWORD i;
HANDLE hProcess;
DWORD pidlistsize;
DWORD nwspages;
SYSTEM_INFO si;
PJOBOBJECT_BASIC_PROCESS_ID_LIST pProcessList;
JOBOBJECT_BASIC_ACCOUNTING_INFORMATION ji;
pbs_task *ptask = NULL;
BOOL is_process_in_job = FALSE;
/* Get the system info */
GetSystemInfo(&si);
/* Get the number of processes embedded in the job */
if (pjob->ji_hJob != NULL &&
QueryInformationJobObject(pjob->ji_hJob,
JobObjectBasicAccountingInformation,
&ji, sizeof(ji), NULL)) {
nps = ji.TotalProcesses;
}
if (nps == 0) {
pjob->ji_flags |= MOM_NO_PROC;
return 0;
}
/* Compute the size of pid list */
pidlistsize = sizeof(JOBOBJECT_BASIC_PROCESS_ID_LIST) +
(nps-1) * sizeof(DWORD);
pProcessList = (PJOBOBJECT_BASIC_PROCESS_ID_LIST) malloc(pidlistsize);
if (pProcessList == NULL) {
log_err(-1, "mem_sum:", "memory allocation failed");
return (0);
}
pProcessList->NumberOfAssignedProcesses = nps;
pProcessList->NumberOfProcessIdsInList = 0;
/* Get the pid list */
if (pjob->ji_hJob != NULL)
QueryInformationJobObject(pjob->ji_hJob,
JobObjectBasicProcessIdList,
pProcessList, pidlistsize, NULL);
/*
* Traverse through each process and find the
* memory used by that process during its execution.
*/
for (i = 0; i < (pProcessList->NumberOfProcessIdsInList); i++) {
hProcess = OpenProcess(PROCESS_QUERY_INFORMATION |
PROCESS_VM_READ,
FALSE, pProcessList->ProcessIdList[i]);
if (hProcess != NULL) {
(void)QueryWorkingSet(hProcess, &nwspages, sizeof(nwspages));
mem += nwspages * (si.dwPageSize >> 10);
CloseHandle(hProcess);
}
}
