1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
#include <windows.h>
#include <assert.h>
#include <psapi.h>
#include <stdio.h>
#include <tchar.h>
#include <time.h>
#include "Shlwapi.h"
#pragma comment(lib, "psapi.lib")
#pragma comment(lib, "shlwapi.lib")
bool gSingleProcess = true;
int gQueryInterval = 5; // seconds
time_t gDuration = 0; // seconds
LPTSTR gCommandLine;
HRESULT ProcessArgs(int argc, TCHAR *argv[]);
HRESULT PrintUsage();
void UseImage(void (functionForQueryType(HANDLE)));
void QueryContinuously(HANDLE hProcess);
time_t ElapsedTime(time_t startTime);
unsigned int OneQuery(HANDLE hProcess);
unsigned int OneQueryMP(HANDLE hProcess);
int __cdecl _tmain (int argc, TCHAR *argv[])
{
HRESULT result = ProcessArgs(argc, argv);
if (FAILED(result))
return result;
UseImage(QueryContinuously);
return S_OK;
}
HRESULT ProcessArgs(int argc, TCHAR *argv[])
{
LPTSTR argument;
for( int count = 1; count < argc; count++ ) {
argument = argv[count] ;
if (wcsstr(argument, _T("-h")) ||
wcsstr(argument, _T("--help")))
return PrintUsage();
else if (wcsstr(argument, _T("--exe"))) {
gCommandLine = argv[++count];
if (wcsstr(gCommandLine, _T("chrome.exe")))
gSingleProcess = false;
} else if (wcsstr(argument, _T("-i")) ||
wcsstr(argument, _T("--interval"))) {
gQueryInterval = _wtoi(argv[++count]);
if (gQueryInterval < 1) {
printf("ERROR: invalid interval\n");
return E_INVALIDARG;
}
} else if (wcsstr(argument, _T("-d")) ||
wcsstr(argument, _T("--duration"))) {
gDuration = _wtoi(argv[++count]);
if (gDuration < 1) {
printf("ERROR: invalid duration\n");
return E_INVALIDARG;
}
} else {
_tprintf(_T("ERROR: unrecognized argument \"%s\"\n"), (LPCTSTR)argument);
return PrintUsage();
}
}
if (argc < 2 || !wcslen(gCommandLine) ) {
printf("ERROR: executable path is required\n");
return PrintUsage();
}
return S_OK;
}
HRESULT PrintUsage()
{
printf("record-memory-win --exe EXE_PATH\n");
printf(" Launch an executable and print the memory usage (in Private Bytes)\n");
printf(" of the process.\n\n");
printf("Usage:\n");
printf("-h [--help] : Print usage\n");
printf("--exe arg : Launch specified image. Required\n");
printf("-i [--interval] arg : Print memory usage every arg seconds. Default: 5 seconds\n");
printf("-d [--duration] arg : Run for up to arg seconds. Default: no limit\n\n");
printf("Examples:\n");
printf(" record-memory-win --exe \"C:\\Program Files\\Safari\\Safari.exe\"\n");
printf(" record-memory-win --exe Safari.exe -i 10 -d 7200\n");
return E_FAIL;
}
void UseImage(void (functionForQueryType(HANDLE)))
{
STARTUPINFO si = {0};
si.cb = sizeof(STARTUPINFO);
PROCESS_INFORMATION pi = {0};
// Start the child process.
if(!CreateProcess( NULL, // No module name (use command line)
gCommandLine, // Command line
NULL, // Process handle not inheritable
NULL, // Thread handle not inheritable
FALSE, // Set handle inheritance to FALSE
0, // No creation flags
NULL, // Use parent's environment block
NULL, // Use parent's starting directory
&si, // Pointer to STARTUPINFO structure
&pi )) // Pointer to PROCESS_INFORMATION structure
printf("CreateProcess failed (%d)\n", GetLastError());
else {
printf("Created process\n");
functionForQueryType(pi.hProcess);
// Close process and thread handles.
CloseHandle( pi.hProcess );
CloseHandle( pi.hThread );
}
}
void QueryContinuously(HANDLE hProcess)
{
Sleep(2000); // give the process some time to launch
bool pastDuration = false;
time_t startTime = time(NULL);
unsigned int memUsage = gSingleProcess ? OneQuery(hProcess) : OneQueryMP(hProcess);
while(memUsage && !pastDuration) {
printf( "%u\n", memUsage );
Sleep(gQueryInterval*1000);
memUsage = gSingleProcess ? OneQuery(hProcess) : OneQueryMP(hProcess);
pastDuration = gDuration > 0 ? ElapsedTime(startTime) > gDuration : false;
}
}
// returns elapsed time in seconds
time_t ElapsedTime(time_t startTime)
{
time_t currentTime = time(NULL);
return currentTime - startTime;
}
// returns Commit Size (Private Bytes) in bytes
unsigned int OneQuery(HANDLE hProcess)
{
PROCESS_MEMORY_COUNTERS_EX pmc;
if (NULL == hProcess)
return 0;
if (GetProcessMemoryInfo(hProcess, (PPROCESS_MEMORY_COUNTERS)&pmc, sizeof(pmc)))
return (unsigned)pmc.PrivateUsage;
return 0;
}
// returns Commit Size (Private Bytes) in bytes for multi-process executables
unsigned int OneQueryMP(HANDLE hProcess)
{
unsigned int memUsage = 0;
TCHAR monitoredProcessName[MAX_PATH];
GetProcessImageFileName(hProcess, monitoredProcessName, sizeof(monitoredProcessName)/sizeof(TCHAR));
LPTSTR shortProcessName = PathFindFileName(monitoredProcessName);
DWORD aProcesses[1024], cbNeeded, cProcesses;
HANDLE hFoundProcess;
if (!EnumProcesses(aProcesses, sizeof(aProcesses), &cbNeeded))
return 0;
// Calculate how many process identifiers were returned.
cProcesses = cbNeeded / sizeof(DWORD);
// find existing process
for (unsigned int i = 0; i < cProcesses; i++)
if (aProcesses[i] != 0) {
DWORD retVal = 0;
TCHAR foundProcessName[MAX_PATH];
// Get a handle to the process.
hFoundProcess = OpenProcess(PROCESS_QUERY_INFORMATION |
PROCESS_VM_READ,
FALSE, aProcesses[i]);
// Get the process name.
if (NULL != hFoundProcess) {
HMODULE hMod;
DWORD cbNeeded;
if (EnumProcessModules(hFoundProcess, &hMod, sizeof(hMod), &cbNeeded)) {
GetModuleBaseName(hFoundProcess, hMod, foundProcessName, sizeof(foundProcessName)/sizeof(TCHAR));
if (wcsstr(foundProcessName, shortProcessName))
memUsage += OneQuery(hFoundProcess);
}
}
CloseHandle(hFoundProcess);
}
return memUsage;
}
|
