ReactOS 0.4.16-dev-2332-g4cba65d
Macros | Functions | Variables
perf.c File Reference
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "perflib.h"
#include "winperf.h"
#include "winternl.h"
#include "wine/test.h"
#include "initguid.h"
Include dependency graph for perf.c:

Go to the source code of this file.

Macros

#define GET_FUNCTION(name)   p##name = (void *)GetProcAddress(hadvapi, #name)
 

Functions

 ULONG (WINAPI *pPerfCloseQueryHandle)(HANDLE)
 
PERF_DATA_HEADER DWORD *static void init_functions (void)
 
static ULONG WINAPI test_provider_callback (ULONG code, void *buffer, ULONG size)
 
void test_provider_init (void)
 
 DEFINE_GUID (TestCounterGUID, 0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33)
 
static ULONG64 trunc_nttime_ms (ULONG64 t)
 
static void test_perf_counters (void)
 
 START_TEST (perf)
 

Variables

HANDLE PERF_COUNTER_IDENTIFIER DWORD
 

Macro Definition Documentation

◆ GET_FUNCTION

#define GET_FUNCTION (   name)    p##name = (void *)GetProcAddress(hadvapi, #name)

Function Documentation

◆ DEFINE_GUID()

DEFINE_GUID ( TestCounterGUID  ,
0x12345678  ,
0x1234  ,
0x5678  ,
0x12  ,
0x34  ,
0x11  ,
0x11  ,
0x22  ,
0x22  ,
0x33  ,
0x33   
)

◆ init_functions()

PERF_DATA_HEADER DWORD *static void init_functions ( void  )
static

Definition at line 39 of file perf.c.

40{
41 HANDLE hadvapi = GetModuleHandleA("advapi32.dll");
42
43#define GET_FUNCTION(name) p##name = (void *)GetProcAddress(hadvapi, #name)
44 GET_FUNCTION(PerfCloseQueryHandle);
45 GET_FUNCTION(PerfOpenQueryHandle);
46 GET_FUNCTION(PerfAddCounters);
47 GET_FUNCTION(PerfQueryCounterData);
48#undef GET_FUNCTION
49}
GetModuleHandleA
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
GET_FUNCTION
#define GET_FUNCTION(name)
PerfAddCounters
ULONG WINAPI PerfAddCounters(HANDLE, PERF_COUNTER_IDENTIFIER *, DWORD)
PerfOpenQueryHandle
ULONG WINAPI PerfOpenQueryHandle(const WCHAR *, HANDLE *)
PerfQueryCounterData
ULONG WINAPI PerfQueryCounterData(HANDLE, PERF_DATA_HEADER *, DWORD, DWORD *)
PerfCloseQueryHandle
ULONG WINAPI PerfCloseQueryHandle(HANDLE)

Referenced by START_TEST().

◆ START_TEST()

START_TEST ( perf  )

Definition at line 299 of file perf.c.

300{
301 init_functions();
302
303 test_provider_init();
304 test_perf_counters();
305}
test_perf_counters
static void test_perf_counters(void)
Definition: perf.c:222
test_provider_init
void test_provider_init(void)
Definition: perf.c:57
init_functions
PERF_DATA_HEADER DWORD *static void init_functions(void)
Definition: perf.c:39

◆ test_perf_counters()

static void test_perf_counters ( void  )
static

Definition at line 222 of file perf.c.

223{
224 LARGE_INTEGER freq, qpc1, qpc2, nttime1, nttime2, systime;
225 char buffer[sizeof(PERF_COUNTER_IDENTIFIER) + 8];
226 PERF_COUNTER_IDENTIFIER *counter_id;
227 PERF_DATA_HEADER dh;
228 HANDLE query;
229 DWORD size;
230 ULONG ret;
231
232 if (!pPerfOpenQueryHandle)
233 {
234 win_skip("PerfOpenQueryHandle not found.\n");
235 return;
236 }
237
238 ret = pPerfOpenQueryHandle(NULL, NULL);
239 ok(ret == ERROR_INVALID_PARAMETER, "got ret %lu.\n", ret);
240 ret = pPerfOpenQueryHandle(NULL, &query);
241 ok(!ret, "got ret %lu.\n", ret);
242
243 counter_id = (PERF_COUNTER_IDENTIFIER *)buffer;
244 memset(buffer, 0, sizeof(buffer));
245
246 counter_id->CounterSetGuid = TestCounterGUID;
247 counter_id->CounterId = PERF_WILDCARD_COUNTER;
248 counter_id->InstanceId = PERF_WILDCARD_COUNTER;
249
250 ret = pPerfAddCounters(query, counter_id, sizeof(*counter_id));
251 ok(ret == ERROR_INVALID_PARAMETER, "got ret %lu.\n", ret);
252
253 counter_id->Size = sizeof(*counter_id);
254 ret = pPerfAddCounters(query, counter_id, 8);
255 ok(ret == ERROR_INVALID_PARAMETER, "got ret %lu.\n", ret);
256 ret = pPerfAddCounters(query, counter_id, sizeof(*counter_id));
257 ok(!ret, "got ret %lu.\n", ret);
258 ok(counter_id->Status == ERROR_WMI_GUID_NOT_FOUND, "got Status %#lx.\n", counter_id->Status);
259
260 ret = pPerfQueryCounterData(query, NULL, 0, NULL);
261 ok(ret == ERROR_INVALID_PARAMETER, "got ret %lu.\n", ret);
262
263 size = 0xdeadbeef;
264 ret = pPerfQueryCounterData(query, NULL, 0, &size);
265 ok(ret == ERROR_NOT_ENOUGH_MEMORY, "got ret %lu.\n", ret);
266 ok(size == sizeof(dh), "got size %lu.\n", size);
267
268 ret = pPerfQueryCounterData(query, &dh, sizeof(dh), NULL);
269 ok(ret == ERROR_INVALID_PARAMETER, "got ret %lu.\n", ret);
270
271 QueryPerformanceFrequency(&freq);
272 QueryPerformanceCounter(&qpc1);
273 NtQuerySystemTime(&nttime1);
274
275 size = 0xdeadbeef;
276 ret = pPerfQueryCounterData(query, &dh, sizeof(dh), &size);
277 QueryPerformanceCounter(&qpc2);
278 NtQuerySystemTime(&nttime2);
279 SystemTimeToFileTime(&dh.SystemTime, (FILETIME *)&systime);
280 ok(!ret, "got ret %lu.\n", ret);
281 ok(size == sizeof(dh), "got size %lu.\n", size);
282 ok(dh.dwTotalSize == sizeof(dh), "got dwTotalSize %lu.\n", dh.dwTotalSize);
283 ok(!dh.dwNumCounters, "got dwNumCounters %lu.\n", dh.dwNumCounters);
284 ok(dh.PerfFreq == freq.QuadPart, "got PerfFreq %I64u.\n", dh.PerfFreq);
285 ok(dh.PerfTimeStamp >= qpc1.QuadPart && dh.PerfTimeStamp <= qpc2.QuadPart,
286 "got PerfTimeStamp %I64u, qpc1 %I64u, qpc2 %I64u.\n",
287 dh.PerfTimeStamp, qpc1.QuadPart, qpc2.QuadPart);
288 ok(dh.PerfTime100NSec >= nttime1.QuadPart && dh.PerfTime100NSec <= nttime2.QuadPart,
289 "got PerfTime100NSec %I64u, nttime1 %I64u, nttime2 %I64u.\n",
290 dh.PerfTime100NSec, nttime1.QuadPart, nttime2.QuadPart);
291 ok(systime.QuadPart >= trunc_nttime_ms(nttime1.QuadPart) && systime.QuadPart <= trunc_nttime_ms(nttime2.QuadPart),
292 "got systime %I64u, nttime1 %I64u, nttime2 %I64u, %d.\n",
293 systime.QuadPart, nttime1.QuadPart, nttime2.QuadPart, dh.SystemTime.wMilliseconds);
294
295 ret = pPerfCloseQueryHandle(query);
296 ok(!ret, "got ret %lu.\n", ret);
297}
ok
#define ok(value,...)
Definition: atltest.h:57
ERROR_NOT_ENOUGH_MEMORY
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
NULL
#define NULL
Definition: types.h:112
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
QueryPerformanceFrequency
BOOL WINAPI QueryPerformanceFrequency(OUT PLARGE_INTEGER lpFrequency)
Definition: perfcnt.c:45
QueryPerformanceCounter
BOOL WINAPI QueryPerformanceCounter(OUT PLARGE_INTEGER lpPerformanceCount)
Definition: perfcnt.c:23
SystemTimeToFileTime
BOOL WINAPI SystemTimeToFileTime(IN CONST SYSTEMTIME *lpSystemTime, OUT LPFILETIME lpFileTime)
Definition: time.c:158
ret
return ret
Definition: mutex.c:146
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
buffer
GLuint buffer
Definition: glext.h:5915
size
GLsizeiptr size
Definition: glext.h:5919
win_skip
#define win_skip
Definition: minitest.h:67
NtQuerySystemTime
NTSTATUS NTAPI NtQuerySystemTime(OUT PLARGE_INTEGER SystemTime)
Definition: time.c:569
trunc_nttime_ms
static ULONG64 trunc_nttime_ms(ULONG64 t)
Definition: perf.c:217
PERF_COUNTER_IDENTIFIER
struct _PERF_COUNTER_IDENTIFIER PERF_COUNTER_IDENTIFIER
PERF_WILDCARD_COUNTER
#define PERF_WILDCARD_COUNTER
Definition: perflib.h:94
memset
#define memset(x, y, z)
Definition: compat.h:39
_FILETIME
Definition: mapidefs.h:60
_PERF_COUNTER_IDENTIFIER
Definition: perflib.h:84
_PERF_DATA_HEADER
Definition: perflib.h:97
_PERF_DATA_HEADER::SystemTime
SYSTEMTIME SystemTime
Definition: perflib.h:103
_PERF_DATA_HEADER::PerfTime100NSec
LONGLONG PerfTime100NSec
Definition: perflib.h:101
_PERF_DATA_HEADER::PerfFreq
LONGLONG PerfFreq
Definition: perflib.h:102
_PERF_DATA_HEADER::PerfTimeStamp
LONGLONG PerfTimeStamp
Definition: perflib.h:100
_PERF_DATA_HEADER::dwNumCounters
ULONG dwNumCounters
Definition: perflib.h:99
_PERF_DATA_HEADER::dwTotalSize
ULONG dwTotalSize
Definition: perflib.h:98
_SYSTEMTIME::wMilliseconds
WORD wMilliseconds
Definition: minwinbase.h:263
ULONG
uint32_t ULONG
Definition: typedefs.h:59
_LARGE_INTEGER
Definition: typedefs.h:103
_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:114
ERROR_WMI_GUID_NOT_FOUND
#define ERROR_WMI_GUID_NOT_FOUND
Definition: winerror.h:1653

Referenced by START_TEST().

◆ test_provider_callback()

static ULONG WINAPI test_provider_callback ( ULONG  code,
void *  buffer,
ULONG  size 
)
static

Definition at line 51 of file perf.c.

52{
53 ok(0, "Provider callback called.\n");
54 return ERROR_SUCCESS;
55}
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10

Referenced by test_provider_init().

◆ test_provider_init()

void test_provider_init ( void  )

Definition at line 57 of file perf.c.

58{
59#ifdef __REACTOS__
60 skip("test_provider_init() can't be built until ReactOS has implementations for Perf* functions.\n");
61#else
62 static GUID test_set_guid = {0xdeadbeef, 0x0002, 0x0003, {0x0f, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00 ,0x0a}};
63 static GUID test_set_guid2 = {0xdeadbeef, 0x0003, 0x0003, {0x0f, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00 ,0x0a}};
64 static GUID test_guid = {0xdeadbeef, 0x0001, 0x0002, {0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00 ,0x0a}};
65 static struct
66 {
67 PERF_COUNTERSET_INFO counterset;
68 PERF_COUNTER_INFO counter[2];
69 }
70 pc_template =
71 {
72 {{0}},
73 {
74 {1, PERF_COUNTER_COUNTER, PERF_ATTRIB_BY_REFERENCE, sizeof(PERF_COUNTER_INFO),
75 PERF_DETAIL_NOVICE, 0, 0xdeadbeef},
76 {2, PERF_COUNTER_COUNTER, PERF_ATTRIB_BY_REFERENCE, sizeof(PERF_COUNTER_INFO),
77 PERF_DETAIL_NOVICE, 0, 0xdeadbeef},
78 },
79 };
80
81 PERF_COUNTERSET_INSTANCE *instance;
82 PERF_PROVIDER_CONTEXT prov_context;
83 UINT64 counter1, counter2;
84 HANDLE prov, prov2;
85 ULONG ret, size;
86 BOOL bret;
87
88 prov = (HANDLE)0xdeadbeef;
89 ret = PerfStartProvider(NULL, test_provider_callback, &prov);
90 ok(ret == ERROR_INVALID_PARAMETER, "Got unexpected ret %lu.\n", ret);
91 ok(prov == (HANDLE)0xdeadbeef, "Got unexpected prov %p.\n", prov);
92
93 prov = (HANDLE)0xdeadbeef;
94 ret = PerfStartProvider(&test_guid, test_provider_callback, NULL);
95 ok(ret == ERROR_INVALID_PARAMETER, "Got unexpected ret %lu.\n", ret);
96 ok(prov == (HANDLE)0xdeadbeef, "Got unexpected prov %p.\n", prov);
97
98 prov = (HANDLE)0xdeadbeef;
99 ret = PerfStartProvider(&test_guid, test_provider_callback, &prov);
100 ok(!ret, "Got unexpected ret %lu.\n", ret);
101 ok(prov != (HANDLE)0xdeadbeef, "Provider handle is not set.\n");
102
103 prov2 = prov;
104 ret = PerfStartProvider(&test_guid, test_provider_callback, &prov2);
105 ok(!ret, "Got unexpected ret %lu.\n", ret);
106 ok(prov2 != prov, "Got the same provider handle.\n");
107
108 ret = PerfStopProvider(prov2);
109 ok(!ret, "Got unexpected ret %lu.\n", ret);
110
111 if (0)
112 {
113 /* Access violation on Windows. */
114 PerfStopProvider(prov2);
115 }
116
117 /* Provider handle is a pointer and not a kernel object handle. */
118 bret = DuplicateHandle(GetCurrentProcess(), prov, GetCurrentProcess(), &prov2, 0, FALSE, DUPLICATE_SAME_ACCESS);
119 ok(!bret && GetLastError() == ERROR_INVALID_HANDLE, "Got unexpected bret %d, err %lu.\n", bret, GetLastError());
120 bret = IsBadWritePtr(prov, 8);
121 ok(!bret, "Handle does not point to the data.\n");
122
123 pc_template.counterset.CounterSetGuid = test_set_guid;
124 pc_template.counterset.ProviderGuid = test_guid;
125 pc_template.counterset.NumCounters = 0;
126 pc_template.counterset.InstanceType = PERF_COUNTERSET_SINGLE_INSTANCE;
127 ret = PerfSetCounterSetInfo(prov, &pc_template.counterset, sizeof(pc_template.counterset));
128 ok(ret == ERROR_INVALID_PARAMETER, "Got unexpected ret %lu.\n", ret);
129
130 pc_template.counterset.CounterSetGuid = test_set_guid;
131 pc_template.counterset.ProviderGuid = test_guid;
132 pc_template.counterset.NumCounters = 2;
133 pc_template.counterset.InstanceType = PERF_COUNTERSET_SINGLE_INSTANCE;
134 ret = PerfSetCounterSetInfo(prov, &pc_template.counterset, sizeof(pc_template));
135 ok(!ret, "Got unexpected ret %lu.\n", ret);
136
137 pc_template.counterset.CounterSetGuid = test_set_guid2;
138 /* Looks like ProviderGuid doesn't need to match provider. */
139 pc_template.counterset.ProviderGuid = test_set_guid;
140 pc_template.counterset.NumCounters = 1;
141 pc_template.counterset.InstanceType = PERF_COUNTERSET_SINGLE_INSTANCE;
142 ret = PerfSetCounterSetInfo(prov, &pc_template.counterset, sizeof(pc_template));
143 ok(!ret, "Got unexpected ret %lu.\n", ret);
144
145 ret = PerfSetCounterSetInfo(prov, &pc_template.counterset, sizeof(pc_template));
146 ok(ret == ERROR_ALREADY_EXISTS, "Got unexpected ret %lu.\n", ret);
147
148 SetLastError(0xdeadbeef);
149 instance = PerfCreateInstance(prov, NULL, L"1", 1);
150 ok(!instance, "Got unexpected instance %p.\n", instance);
151 ok(GetLastError() == ERROR_INVALID_PARAMETER, "Got unexpected error %lu.\n", GetLastError());
152
153 SetLastError(0xdeadbeef);
154 instance = PerfCreateInstance(prov, &test_guid, L"1", 1);
155 ok(!instance, "Got unexpected instance %p.\n", instance);
156 ok(GetLastError() == ERROR_NOT_FOUND, "Got unexpected error %lu.\n", GetLastError());
157
158 SetLastError(0xdeadbeef);
159 instance = PerfCreateInstance(prov, &test_guid, NULL, 1);
160 ok(!instance, "Got unexpected instance %p.\n", instance);
161 ok(GetLastError() == ERROR_INVALID_PARAMETER, "Got unexpected error %lu.\n", GetLastError());
162
163 SetLastError(0xdeadbeef);
164 instance = PerfCreateInstance(prov, &test_set_guid, L"11", 1);
165 ok(!!instance, "Got NULL instance.\n");
166 ok(GetLastError() == 0xdeadbeef, "Got unexpected error %lu.\n", GetLastError());
167 ok(instance->InstanceId == 1, "Got unexpected InstanceId %lu.\n", instance->InstanceId);
168 ok(instance->InstanceNameSize == 6, "Got unexpected InstanceNameSize %lu.\n", instance->InstanceNameSize);
169 ok(IsEqualGUID(&instance->CounterSetGuid, &test_set_guid), "Got unexpected guid %s.\n",
170 debugstr_guid(&instance->CounterSetGuid));
171
172 ok(instance->InstanceNameOffset == sizeof(*instance) + sizeof(UINT64) * 2,
173 "Got unexpected InstanceNameOffset %lu.\n", instance->InstanceNameOffset);
174 ok(!lstrcmpW((WCHAR *)((BYTE *)instance + instance->InstanceNameOffset), L"11"),
175 "Got unexpected instance name %s.\n",
176 debugstr_w((WCHAR *)((BYTE *)instance + instance->InstanceNameOffset)));
177 size = ((sizeof(*instance) + sizeof(UINT64) * 2 + instance->InstanceNameSize) + 7) & ~7;
178 ok(size == instance->dwSize, "Got unexpected size %lu, instance->dwSize %lu.\n", size, instance->dwSize);
179
180 ret = PerfSetCounterRefValue(prov, instance, 1, &counter1);
181 ok(!ret, "Got unexpected ret %lu.\n", ret);
182 ret = PerfSetCounterRefValue(prov, instance, 2, &counter2);
183 ok(!ret, "Got unexpected ret %lu.\n", ret);
184
185 ret = PerfSetCounterRefValue(prov, instance, 0, &counter2);
186 ok(ret == ERROR_NOT_FOUND, "Got unexpected ret %lu.\n", ret);
187
188 ok(*(void **)(instance + 1) == &counter1, "Got unexpected counter value %p.\n",
189 *(void **)(instance + 1));
190 ok(*(void **)((BYTE *)instance + sizeof(*instance) + sizeof(UINT64)) == &counter2,
191 "Got unexpected counter value %p.\n", *(void **)(instance + 1));
192
193 ret = PerfDeleteInstance(prov, instance);
194 ok(!ret, "Got unexpected ret %lu.\n", ret);
195
196 ret = PerfStopProvider(prov);
197 ok(!ret, "Got unexpected ret %lu.\n", ret);
198
199 memset( &prov_context, 0, sizeof(prov_context) );
200 prov = (HANDLE)0xdeadbeef;
201 ret = PerfStartProviderEx( &test_guid, &prov_context, &prov );
202 ok(ret == ERROR_INVALID_PARAMETER, "Got unexpected ret %lu.\n", ret);
203 ok(prov == (HANDLE)0xdeadbeef, "Got unexpected prov %p.\n", prov);
204
205 prov_context.ContextSize = sizeof(prov_context) + 1;
206 ret = PerfStartProviderEx( &test_guid, &prov_context, &prov );
207 ok(!ret, "Got unexpected ret %lu.\n", ret);
208 ok(prov != (HANDLE)0xdeadbeef, "Provider handle is not set.\n");
209
210 ret = PerfStopProvider(prov);
211 ok(!ret, "Got unexpected ret %lu.\n", ret);
212#endif
213}
UINT64
COMPILER_DEPENDENT_UINT64 UINT64
Definition: actypes.h:131
skip
#define skip(...)
Definition: atltest.h:64
FALSE
#define FALSE
Definition: types.h:117
instance
static HINSTANCE instance
Definition: main.c:40
SetLastError
#define SetLastError(x)
Definition: compat.h:752
GetCurrentProcess
#define GetCurrentProcess()
Definition: compat.h:759
ERROR_INVALID_HANDLE
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
IsBadWritePtr
BOOL NTAPI IsBadWritePtr(IN LPVOID lp, IN UINT_PTR ucb)
Definition: except.c:883
DuplicateHandle
BOOL WINAPI DuplicateHandle(IN HANDLE hSourceProcessHandle, IN HANDLE hSourceHandle, IN HANDLE hTargetProcessHandle, OUT LPHANDLE lpTargetHandle, IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwOptions)
Definition: handle.c:149
lstrcmpW
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4152
PerfStopProvider
ULONG WINAPI PerfStopProvider(HANDLE handle)
Definition: main.c:380
PerfDeleteInstance
ULONG WINAPI PerfDeleteInstance(HANDLE provider, PERF_COUNTERSET_INSTANCE *block)
Definition: main.c:248
PerfCreateInstance
PERF_COUNTERSET_INSTANCE WINAPI * PerfCreateInstance(HANDLE handle, const GUID *guid, const WCHAR *name, ULONG id)
Definition: main.c:185
PerfStartProvider
ULONG WINAPI PerfStartProvider(GUID *guid, PERFLIBREQUEST callback, HANDLE *provider)
Definition: main.c:340
PerfSetCounterRefValue
ULONG WINAPI PerfSetCounterRefValue(HANDLE provider, PERF_COUNTERSET_INSTANCE *instance, ULONG counterid, void *address)
Definition: main.c:312
PerfSetCounterSetInfo
ULONG WINAPI PerfSetCounterSetInfo(HANDLE handle, PERF_COUNTERSET_INFO *template, ULONG size)
Definition: main.c:267
PerfStartProviderEx
ULONG WINAPI PerfStartProviderEx(GUID *guid, PERF_PROVIDER_CONTEXT *context, HANDLE *provider)
Definition: main.c:356
L
#define L(x)
Definition: resources.c:13
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
debugstr_guid
#define debugstr_guid
Definition: kernel32.h:35
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
ERROR_ALREADY_EXISTS
#define ERROR_ALREADY_EXISTS
Definition: disk.h:80
test_provider_callback
static ULONG WINAPI test_provider_callback(ULONG code, void *buffer, ULONG size)
Definition: perf.c:51
PERF_COUNTER_INFO
struct _PERF_COUNTER_INFO PERF_COUNTER_INFO
PERF_COUNTERSET_SINGLE_INSTANCE
#define PERF_COUNTERSET_SINGLE_INSTANCE
Definition: perflib.h:43
PERF_ATTRIB_BY_REFERENCE
#define PERF_ATTRIB_BY_REFERENCE
Definition: perflib.h:69
IsEqualGUID
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
_PERF_COUNTERSET_INFO
Definition: perflib.h:30
_PERF_COUNTERSET_INSTANCE
Definition: perflib.h:50
_PERF_COUNTER_INFO
Definition: perflib.h:58
_PROVIDER_CONTEXT
Definition: perflib.h:75
_PROVIDER_CONTEXT::ContextSize
DWORD ContextSize
Definition: perflib.h:76
HANDLE
PVOID HANDLE
Definition: typedefs.h:73
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
ERROR_NOT_FOUND
#define ERROR_NOT_FOUND
Definition: winerror.h:1014
PERF_DETAIL_NOVICE
#define PERF_DETAIL_NOVICE
Definition: winperf.h:48
PERF_COUNTER_COUNTER
#define PERF_COUNTER_COUNTER
Definition: winperf.h:52
DUPLICATE_SAME_ACCESS
#define DUPLICATE_SAME_ACCESS
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
BYTE
unsigned char BYTE
Definition: xxhash.c:193

Referenced by START_TEST().

◆ trunc_nttime_ms()

static ULONG64 trunc_nttime_ms ( ULONG64  t)
static

Definition at line 217 of file perf.c.

218{
219 return (t / 10000) * 10000;
220}
t
GLdouble GLdouble t
Definition: gl.h:2047

Referenced by test_perf_counters().

◆ ULONG()

ULONG ( WINAPI *  pPerfCloseQueryHandle)

Variable Documentation

◆ DWORD

PERF_DATA_HEADER DWORD

Definition at line 36 of file perf.c.