[PATCH RFC 0/5] Timer Resolution

[Arkadiusz Hiler]

TL;DR: Good learning experience, lead to a fix in winmm but IMO we are better
       off defaulting to 1ms resolution and avoid all the extra complications.

The whole thing started because of miss-assigning blame for DOSBox regression
to mismatched GetTickCount() and Sleep() resolutions. Initial attempts at
fixing the issue just made Sleep() work in increments of 15.6ms.

Then, I have learned about timer resolution and I have started implementing
this series. As soon as I had working timeBeginPeriod() DOSBox regressed
again.

After some confusing debugging of "phantom" calls to GetTickCount() with
1-call stacktraces and building myself and unoptimized debug version of SDL
and DOSBox I have found out that, in Wine, timeGetTime() is an alias for
GetTickCount() and this has caused the problem.

More details here: https://www.winehq.org/pipermail/wine-devel/2020-August/171965.html

I have started questioning usefulness and feasibility of implementing
resolution support:

- introducing extra branching for each Sleep / Wait call
 - multiple places to maintain (some wait calls use server_wait, other call server directly)
 - a lot of Sleep(1) to assess across Wine's codebase
 - per-process implementation may be not sufficient for some multi-process software

I did testing with popular software and a lot of things set resolution:

* Chrome and a lot of Electron-based apps - 1ms with multimedia content,
                                             fluctuating otherwise
 * Firefox - 8ms when downloading, 5ms when playing music/videos
 * Visual Studio - 1ms all the time
 * Discord - 1ms all the time while being on a voice chat
 * Spotify - oscillating 1-5ms when playing music
 * EGS - 1ms
 * many many games

Resolution is global - if one process requests high resolution (i.e. low
update interval) the whole system gets it.

Conjecture: If having 1ms resolution all the time / by default would cause any
noticeable problems / performance issue with software, it would be seen on
Windows and loudly complained about.

I think it's worth abandoning the effort to implement proper resolution
setting, default to 1ms and implement more convincing stubs for
timeBeginPeriod() and NtSetTimerResolution() and friends.

Any thoughts?

Cc: Rémi Bernon 
Cc: Paul Gofman

Arkadiusz Hiler (5):
  ntdll: Implmement NtQueryTimerResolution and NtSetTimerResolution
  ntdll: Make wait/delay calls respect the timer resolution
  server: Set the worst case time for updating user_shared_data to 15ms
  ntdll: Remove todo_wine from tick count vs sleep test
  winmm: Implement timeBeginPeriod() and timeEndPeriod()

dlls/ntdll/tests/time.c        | 187 ++++++++++++++++++++++++++++++++-
 dlls/ntdll/unix/server.c       |  16 ++-
 dlls/ntdll/unix/sync.c         |  84 +++++++++++++--
 dlls/ntdll/unix/unix_private.h |  10 ++
 dlls/winmm/tests/timer.c       |  46 +++++++-
 dlls/winmm/time.c              |  76 +++++++++++---
 server/fd.c                    |   2 +-
 7 files changed, 396 insertions(+), 25 deletions(-)

[PATCH 1/5] ntdll: Implmement NtQueryTimerResolution and NtSetTimerResolution

[Arkadiusz Hiler]

This change implements querying, setting and resetting timer resolution. The
set resolution has no effect on any of the wait calls yet - they are still
using select() or server_select() with the raw values.

Signed-off-by: Arkadiusz Hiler 
---
 dlls/ntdll/tests/time.c | 32 +++++++++++++++++++++++
 dlls/ntdll/unix/sync.c  | 57 ++++++++++++++++++++++++++++++++++++++---
 2 files changed, 85 insertions(+), 4 deletions(-)

diff --git a/dlls/ntdll/tests/time.c b/dlls/ntdll/tests/time.c
index a00d507e4e..6c800c8c4e 100644
--- a/dlls/ntdll/tests/time.c
+++ b/dlls/ntdll/tests/time.c
@@ -35,6 +35,9 @@ static NTSTATUS (WINAPI *pRtlQueryTimeZoneInformation)( RTL_TIME_ZONE_INFORMATIO
 static NTSTATUS (WINAPI *pRtlQueryDynamicTimeZoneInformation)( RTL_DYNAMIC_TIME_ZONE_INFORMATION *);
 static BOOL     (WINAPI *pRtlQueryUnbiasedInterruptTime)( ULONGLONG *time );

+static NTSTATUS (WINAPI *pNtQueryTimerResolution)( ULONG *min_res, ULONG *max_res, ULONG *current_res );
+static NTSTATUS (WINAPI *pNtSetTimerResolution)( ULONG res, BOOLEAN set, ULONG *current_res );
+
 static const int MonthLengths[2][12] =
 {
    { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
@@ -264,6 +267,32 @@ static void test_user_shared_data_time(void)
     todo_wine ok(changed >= 90, "tick count isn't updated after sleeping one millisecond (%d%% correct)\n", changed);
 }

+static void test_timer_resolution(void)
+{
+    ULONG min, max, cur, def, cur2;
+
+    ok(pNtQueryTimerResolution(NULL, NULL, NULL) == STATUS_ACCESS_VIOLATION, "getting resolution is fine with writign to a NULL pointer\n");
+    ok(pNtQueryTimerResolution(&min, &max, &def) == STATUS_SUCCESS, "failed to get resolution\n");
+    ok(def == min, "the default timer resolution is not set to the minimum\n");
+
+    ok(pNtSetTimerResolution(0, TRUE, NULL) == STATUS_ACCESS_VIOLATION, "setting resolution is fine with writing to a NULL pointer\n");
+    ok(pNtSetTimerResolution(0, FALSE, &cur) == STATUS_TIMER_RESOLUTION_NOT_SET, "we have managed to unset resolution without setting one\n");
+
+    ok(pNtSetTimerResolution(20000, TRUE, &cur) == STATUS_SUCCESS, "filed to set timer resolution\n");
+    ok(cur <= 20000 && cur >= 20000/2, "resoltuion was set to %u which is not close to the requested one\n", cur);
+
+    ok(pNtQueryTimerResolution(&min, &max, &cur2) == STATUS_SUCCESS, "failed to get resolution\n");
+    ok(cur2 == cur, "setting and quering resoltions report mismatched values %u != %u\n", cur2, cur);
+
+    ok(pNtSetTimerResolution(100000, TRUE, &cur) == STATUS_SUCCESS, "failed to decrease resolution\n");
+    ok(cur <= 100000 && cur >= 100000/2, "resolution was set to %u which is not close to the requested one\n", cur);
+
+    ok(pNtSetTimerResolution(123456, FALSE, &cur) == STATUS_SUCCESS, "failed to unset resolution\n");
+    ok(cur == def, "after unsetting we've got %u instead of the default %u\n", cur, def);
+
+    ok(pNtSetTimerResolution(123456, FALSE, &cur) == STATUS_TIMER_RESOLUTION_NOT_SET, "we have unset resolution more times than one\n");
+}
+
 START_TEST(time)
 {
     HMODULE mod = GetModuleHandleA("ntdll.dll");
@@ -276,6 +305,8 @@ START_TEST(time)
     pRtlQueryDynamicTimeZoneInformation =
         (void *)GetProcAddress(mod, "RtlQueryDynamicTimeZoneInformation");
     pRtlQueryUnbiasedInterruptTime = (void *)GetProcAddress(mod, "RtlQueryUnbiasedInterruptTime");
+    pNtQueryTimerResolution = (void *)GetProcAddress(mod, "NtQueryTimerResolution");
+    pNtSetTimerResolution = (void *)GetProcAddress(mod, "NtSetTimerResolution");

if (pRtlTimeToTimeFields && pRtlTimeFieldsToTime)
         test_pRtlTimeToTimeFields();
@@ -284,4 +315,5 @@ START_TEST(time)
     test_NtQueryPerformanceCounter();
     test_RtlQueryTimeZoneInformation();
     test_user_shared_data_time();
+    test_timer_resolution();
 }
diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c
index 23dca9c61b..eb93ac0d4b 100644
--- a/dlls/ntdll/unix/sync.c
+++ b/dlls/ntdll/unix/sync.c
@@ -81,6 +81,15 @@ static const LARGE_INTEGER zero_timeout;

static pthread_mutex_t addr_mutex = PTHREAD_MUTEX_INITIALIZER;

+static ULONG timer_resolution_current = 0;
+static const ULONG timer_resolution_min = 156250; /* also the default */
+static const ULONG timer_resolution_max = 5000;
+
+static ULONG get_timer_resolution(void)
+{
+    return timer_resolution_current ? timer_resolution_current : timer_resolution_min;
+}
+
 /* return a monotonic time counter, in Win32 ticks */
 static inline ULONGLONG monotonic_counter(void)
 {
@@ -1438,8 +1447,19 @@ NTSTATUS WINAPI NtSetSystemTime( const LARGE_INTEGER *new, LARGE_INTEGER *old )
  */
 NTSTATUS WINAPI NtQueryTimerResolution( ULONG *min_res, ULONG *max_res, ULONG *current_res )
 {
-    FIXME( "(%p,%p,%p), stub!\n", min_res, max_res, current_res );
-    return STATUS_NOT_IMPLEMENTED;
+    __TRY
+    {
+        *min_res = timer_resolution_min;
+        *max_res = timer_resolution_max;
+        *current_res = get_timer_resolution();
+    }
+    __EXCEPT_PAGE_FAULT
+    {
+        return STATUS_ACCESS_VIOLATION;
+    }
+    __ENDTRY
+
+    return STATUS_SUCCESS;
 }

@@ -1448,8 +1468,37 @@ NTSTATUS WINAPI NtQueryTimerResolution( ULONG *min_res, ULONG *max_res, ULONG *c
  */
 NTSTATUS WINAPI NtSetTimerResolution( ULONG res, BOOLEAN set, ULONG *current_res )
 {
-    FIXME( "(%u,%u,%p), stub!\n", res, set, current_res );
-    return STATUS_NOT_IMPLEMENTED;
+    __TRY
+    {
+        *current_res =  timer_resolution_current;
+    }
+    __EXCEPT_PAGE_FAULT
+    {
+        return STATUS_ACCESS_VIOLATION;
+    }
+    __ENDTRY
+
+    if (set)
+    {
+        if (res < timer_resolution_max)
+            res = timer_resolution_max;
+
+        if (res > timer_resolution_min)
+            res = timer_resolution_min;
+
+        InterlockedExchange( (LONG*) &timer_resolution_current, res );
+    }
+    else
+    {
+        ULONG original = InterlockedExchange( (LONG*) &timer_resolution_current, 0 );
+
+        if (original == 0)
+            return STATUS_TIMER_RESOLUTION_NOT_SET;
+    }
+
+    *current_res = get_timer_resolution();
+
+    return STATUS_SUCCESS;
 }

[PATCH 1/5] ntdll: Implmement NtQueryTimerResolution and NtSetTimerResolution

[Marvin]

Hi,

While running your changed tests, I think I found new failures.
Being a bot and all I'm not very good at pattern recognition, so I might be
wrong, but could you please double-check?

Full results can be found at:
https://testbot.winehq.org/JobDetails.pl?Key=77259

Your paranoid android.

=== w2008s64 (32 bit report) ===

ntdll:
time.c:288: Test failed: resolution was set to 19531 which is not close to the requested one

=== w2008s64 (64 bit report) ===

ntdll:
time.c:288: Test failed: resolution was set to 19531 which is not close to the requested one

[PATCH 2/5] ntdll: Make wait/delay calls respect the timer resolution

[Arkadiusz Hiler]

NtDelayExecution() and all the calls using server_wait() are now rounding up
their wait times to the next multiply of set timer resolution.

Affected calls are:
 * NtDelayExecution()
 * NtWaitForSingleObject()
 * NtWaitForMultipleObjects()
 * NtSignalAndWaitForSingleObject()
 * NtCreateKeyedEvent()
 * NtWaitForKeyedEvent()
 * NtReleaseKeyedEvent()

Signed-off-by: Arkadiusz Hiler 
---
 dlls/ntdll/tests/time.c        | 153 +++++++++++++++++++++++++++++++++
 dlls/ntdll/unix/server.c       |  16 +++-
 dlls/ntdll/unix/sync.c         |  29 +++++--
 dlls/ntdll/unix/unix_private.h |  10 +++
 4 files changed, 201 insertions(+), 7 deletions(-)

diff --git a/dlls/ntdll/tests/time.c b/dlls/ntdll/tests/time.c
index 6c800c8c4e..0f4096f708 100644
--- a/dlls/ntdll/tests/time.c
+++ b/dlls/ntdll/tests/time.c
@@ -37,6 +37,13 @@ static BOOL     (WINAPI *pRtlQueryUnbiasedInterruptTime)( ULONGLONG *time );

static NTSTATUS (WINAPI *pNtQueryTimerResolution)( ULONG *min_res, ULONG *max_res, ULONG *current_res );
 static NTSTATUS (WINAPI *pNtSetTimerResolution)( ULONG res, BOOLEAN set, ULONG *current_res );
+static NTSTATUS (WINAPI *pNtWaitForSingleObject)(HANDLE, BOOLEAN, const LARGE_INTEGER *);
+static NTSTATUS (WINAPI *pNtWaitForMultipleObjects)(ULONG,const HANDLE*,BOOLEAN,BOOLEAN,const LARGE_INTEGER*);
+static NTSTATUS (WINAPI *pNtSignalAndWaitForSingleObject)( HANDLE signal, HANDLE wait,
+                                                           BOOLEAN alertable, const LARGE_INTEGER *timeout );
+static NTSTATUS (WINAPI *pNtCreateKeyedEvent)( HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES *, ULONG );
+static NTSTATUS (WINAPI *pNtWaitForKeyedEvent)( HANDLE, const void *, BOOLEAN, const LARGE_INTEGER * );
+static NTSTATUS (WINAPI *pNtReleaseKeyedEvent)( HANDLE, const void *, BOOLEAN, const LARGE_INTEGER * );

static const int MonthLengths[2][12] =
 {
@@ -267,6 +274,46 @@ static void test_user_shared_data_time(void)
     todo_wine ok(changed >= 90, "tick count isn't updated after sleeping one millisecond (%d%% correct)\n", changed);
 }

+BOOL spin_the_thread = TRUE;
+
+DWORD WINAPI spinner_thread(void *arg)
+{
+    while (spin_the_thread)
+        Sleep(1);
+
+    return 0;
+}
+
+#define OBEYS_RESOLUTION(call) \
+        for (ULONGLONG _resolution = 30000; _resolution <= 90000; _resolution += 30000) \
+        {                                                                               \
+            ULONG _cur;                                                                 \
+            LARGE_INTEGER _counter[21];                                                 \
+            int _hits = 0;                                                              \
+            pNtSetTimerResolution(_resolution, TRUE, &_cur);                            \
+                                                                                        \
+            QueryPerformanceCounter(&_counter[0]);                                      \
+            for (int _i = 1; _i < ARRAYSIZE(_counter); _i++)                            \
+            {                                                                           \
+                (call);                                                                 \
+                QueryPerformanceCounter(&_counter[_i]);                                 \
+            }                                                                           \
+                                                                                        \
+            for (int _i = 1; _i < ARRAYSIZE(_counter); _i++)                            \
+            {                                                                           \
+                ULONGLONG _delta = _counter[_i].QuadPart - _counter[_i-1].QuadPart;     \
+                if (((_cur-20000) < _delta) && ((_cur+20000) > _delta))                  \
+                    _hits++;                                                            \
+            }                                                                           \
+                                                                                        \
+            pNtSetTimerResolution(_resolution, FALSE, &_cur);                           \
+                                                                                        \
+            ok(_hits >= ((8*ARRAYSIZE(_counter)-1)/10),                                 \
+               #call " hit the expected interval only %u times out of %u for res %u\n", \
+               _hits, ARRAYSIZE(_counter)-1, _resolution);                              \
+        }
+
+
 static void test_timer_resolution(void)
 {
     ULONG min, max, cur, def, cur2;
@@ -291,6 +338,105 @@ static void test_timer_resolution(void)
     ok(cur == def, "after unsetting we've got %u instead of the default %u\n", cur, def);

ok(pNtSetTimerResolution(123456, FALSE, &cur) == STATUS_TIMER_RESOLUTION_NOT_SET, "we have unset resolution more times than one\n");
+
+    {
+        LARGE_INTEGER timeout;
+
+        timeout.QuadPart = -10000;
+        OBEYS_RESOLUTION(NtDelayExecution(TRUE, &timeout));
+        OBEYS_RESOLUTION(NtDelayExecution(FALSE, &timeout));
+
+        OBEYS_RESOLUTION(
+        {
+            NtQuerySystemTime(&timeout);
+            timeout.QuadPart += 10000;
+            NtDelayExecution(TRUE, &timeout);
+        });
+
+        OBEYS_RESOLUTION(
+        {
+            NtQuerySystemTime(&timeout);
+            timeout.QuadPart += 10000;
+            NtDelayExecution(FALSE, &timeout);
+        });
+    }
+
+    {
+        DWORD thread_id;
+        LARGE_INTEGER timeout;
+        HANDLE thread = CreateThread( NULL, 0, spinner_thread, NULL, 0, &thread_id );
+        HANDLE event = CreateEventA( NULL, TRUE, FALSE, NULL );
+
+        timeout.QuadPart = -10000;
+        OBEYS_RESOLUTION(pNtWaitForSingleObject( thread, TRUE, &timeout ));
+        OBEYS_RESOLUTION(pNtWaitForSingleObject( thread, FALSE, &timeout ));
+
+        OBEYS_RESOLUTION(
+        {
+            NtQuerySystemTime(&timeout);
+            timeout.QuadPart += 10000;
+            pNtWaitForSingleObject( thread, TRUE, &timeout );
+        });
+
+        OBEYS_RESOLUTION(
+        {
+            NtQuerySystemTime(&timeout);
+            timeout.QuadPart += 10000;
+            pNtWaitForSingleObject( thread, FALSE, &timeout );
+        });
+
+        /* XXX: saving some test time here on just the relative alertable variants */
+        timeout.QuadPart = -10000;
+        OBEYS_RESOLUTION(pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ));
+        OBEYS_RESOLUTION({
+            pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout );
+            ResetEvent( event );
+        });
+
+        spin_the_thread = FALSE;
+        WaitForSingleObject( thread, 0 );
+    }
+
+    {
+        HANDLE event;
+        LARGE_INTEGER timeout;
+        timeout.QuadPart = -10000;
+
+        ok(pNtCreateKeyedEvent( &event, GENERIC_ALL, NULL, 0 ) == STATUS_SUCCESS, "failed to create keyed event\n");
+        OBEYS_RESOLUTION(pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ));
+        OBEYS_RESOLUTION(pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ));
+        OBEYS_RESOLUTION(pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ));
+        OBEYS_RESOLUTION(pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ));
+
+        OBEYS_RESOLUTION(
+        {
+            NtQuerySystemTime( &timeout );
+            timeout.QuadPart += 10000;
+            pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout );
+        });
+
+        OBEYS_RESOLUTION(
+        {
+            NtQuerySystemTime( &timeout );
+            timeout.QuadPart += 10000;
+            pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout );
+        });
+
+        OBEYS_RESOLUTION(
+        {
+            NtQuerySystemTime( &timeout );
+            timeout.QuadPart += 10000;
+            pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout );
+        });
+
+        OBEYS_RESOLUTION(
+        {
+            NtQuerySystemTime( &timeout );
+            timeout.QuadPart += 10000;
+            pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout );
+        });
+    }
+
 }

START_TEST(time)
@@ -305,8 +451,15 @@ START_TEST(time)
     pRtlQueryDynamicTimeZoneInformation =
         (void *)GetProcAddress(mod, "RtlQueryDynamicTimeZoneInformation");
     pRtlQueryUnbiasedInterruptTime = (void *)GetProcAddress(mod, "RtlQueryUnbiasedInterruptTime");
+
     pNtQueryTimerResolution = (void *)GetProcAddress(mod, "NtQueryTimerResolution");
     pNtSetTimerResolution = (void *)GetProcAddress(mod, "NtSetTimerResolution");
+    pNtWaitForSingleObject = (void *)GetProcAddress(mod, "NtWaitForSingleObject");
+    pNtWaitForMultipleObjects = (void *)GetProcAddress(mod, "NtWaitForMultipleObjects");
+    pNtSignalAndWaitForSingleObject = (void *)GetProcAddress(mod, "NtSignalAndWaitForSingleObject");
+    pNtCreateKeyedEvent = (void *)GetProcAddress(mod, "NtCreateKeyedEvent");
+    pNtWaitForKeyedEvent = (void *)GetProcAddress(mod, "NtWaitForKeyedEvent");
+    pNtReleaseKeyedEvent = (void *)GetProcAddress(mod, "NtReleaseKeyedEvent");

if (pRtlTimeToTimeFields && pRtlTimeFieldsToTime)
         test_pRtlTimeToTimeFields();
diff --git a/dlls/ntdll/unix/server.c b/dlls/ntdll/unix/server.c
index d867a7fb46..17d125bbf6 100644
--- a/dlls/ntdll/unix/server.c
+++ b/dlls/ntdll/unix/server.c
@@ -672,11 +672,23 @@ unsigned int server_wait( const select_op_t *select_op, data_size_t size, UINT f
     user_apc_t apc;

if (abs_timeout < 0)
+    {
+        LARGE_INTEGER since_server_start;
+
+        NtQueryPerformanceCounter( &since_server_start, NULL );
+        abs_timeout = -multiple_of_time_resolution( -abs_timeout );
+        abs_timeout -= since_server_start.QuadPart;
+    }
+    else
     {
         LARGE_INTEGER now;

-        NtQueryPerformanceCounter( &now, NULL );
-        abs_timeout -= now.QuadPart;
+        NtQuerySystemTime( &now );
+        if (abs_timeout > now.QuadPart)
+        {
+            abs_timeout = multiple_of_time_resolution( abs_timeout - now.QuadPart );
+            abs_timeout += now.QuadPart;
+        }
     }

ret = server_select( select_op, size, flags, abs_timeout, NULL, NULL, &apc );
diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c
index eb93ac0d4b..8d4cc580eb 100644
--- a/dlls/ntdll/unix/sync.c
+++ b/dlls/ntdll/unix/sync.c
@@ -85,7 +85,7 @@ static ULONG timer_resolution_current = 0;
 static const ULONG timer_resolution_min = 156250; /* also the default */
 static const ULONG timer_resolution_max = 5000;

-static ULONG get_timer_resolution(void)
+ULONG get_timer_resolution(void)
 {
     return timer_resolution_current ? timer_resolution_current : timer_resolution_min;
 }
@@ -1341,10 +1341,17 @@ NTSTATUS WINAPI NtDelayExecution( BOOLEAN alertable, const LARGE_INTEGER *timeou
         LARGE_INTEGER now;
         timeout_t when, diff;

+        NtQuerySystemTime( &now );
+
         if ((when = timeout->QuadPart) < 0)
         {
-            NtQuerySystemTime( &now );
-            when = now.QuadPart - when;
+            when = multiple_of_time_resolution( -when );
+            when += now.QuadPart;
+        }
+        else if (when > now.QuadPart)
+        {
+            when = multiple_of_time_resolution( when - now.QuadPart );
+            when += now.QuadPart;
         }

/* Note that we yield after establishing the desired timeout */
@@ -2782,11 +2789,23 @@ NTSTATUS WINAPI RtlWaitOnAddress( const void *addr, const void *cmp, SIZE_T size
     }

if (abs_timeout < 0)
+    {
+        LARGE_INTEGER since_server_start;
+
+        NtQueryPerformanceCounter( &since_server_start, NULL );
+        abs_timeout = -multiple_of_time_resolution( -abs_timeout );
+        abs_timeout -= since_server_start.QuadPart;
+    }
+    else
     {
         LARGE_INTEGER now;

-        NtQueryPerformanceCounter( &now, NULL );
-        abs_timeout -= now.QuadPart;
+        NtQuerySystemTime( &now );
+        if (abs_timeout > now.QuadPart)
+        {
+            abs_timeout = multiple_of_time_resolution( abs_timeout - now.QuadPart );
+            abs_timeout += now.QuadPart;
+        }
     }

select_op.keyed_event.op     = SELECT_KEYED_EVENT_WAIT;
diff --git a/dlls/ntdll/unix/unix_private.h b/dlls/ntdll/unix/unix_private.h
index 397211957b..5b23c4e2aa 100644
--- a/dlls/ntdll/unix/unix_private.h
+++ b/dlls/ntdll/unix/unix_private.h
@@ -264,6 +264,10 @@ extern void WINAPI DECLSPEC_NORETURN call_user_exception_dispatcher( EXCEPTION_R
                                                                      NTSTATUS (WINAPI *dispatcher)(EXCEPTION_RECORD*,CONTEXT*) ) DECLSPEC_HIDDEN;
 extern void WINAPI DECLSPEC_NORETURN call_raise_user_exception_dispatcher( NTSTATUS (WINAPI *dispatcher)(void) ) DECLSPEC_HIDDEN;

+extern ULONG get_timer_resolution(void) DECLSPEC_HIDDEN;
+
+
+
 #define TICKSPERSEC 10000000
 #define SECS_1601_TO_1970  ((369 * 365 + 89) * (ULONGLONG)86400)
 #define TICKS_1601_TO_1970 (SECS_1601_TO_1970 * TICKSPERSEC)
@@ -291,6 +295,12 @@ static inline void *get_signal_stack(void)
     return (char *)NtCurrentTeb() + teb_size - teb_offset;
 }

+static inline timeout_t multiple_of_time_resolution(timeout_t timeout)
+{
+    ULONG res = get_timer_resolution();
+    return ((timeout + res - 1) / res) * res;
+}
+
 #ifndef _WIN64
 static inline TEB64 *NtCurrentTeb64(void) { return (TEB64 *)NtCurrentTeb()->GdiBatchCount; }
 #endif

[PATCH 2/5] ntdll: Make wait/delay calls respect the timer resolution

[Marvin]

Hi,

While running your changed tests, I think I found new failures.
Being a bot and all I'm not very good at pattern recognition, so I might be
wrong, but could you please double-check?

Full results can be found at:
https://testbot.winehq.org/JobDetails.pl?Key=77260

Your paranoid android.

=== w2008s64 (32 bit report) ===

ntdll:
time.c:335: Test failed: resolution was set to 19531 which is not close to the requested one
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 1 times out of 20 for res 60000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 1 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 1 times out of 20 for res 60000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000

=== w8 (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 1 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000

=== w8adm (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000

=== w1064v1507 (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000

=== w1064v1809 (32 bit report) ===

ntdll:
time.c:323: Test failed: the default timer resolution is not set to the minimum
time.c:335: Test failed: resolution was set to 43945 which is not close to the requested one
time.c:338: Test failed: after unsetting we've got 24414 instead of the default 63476
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 13 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000

=== w1064v1809_2scr (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 15 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000

=== w1064v1809_ar (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 13 times out of 20 for res 60000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 15 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 14 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 15 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 15 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 15 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 13 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 7 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 12 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 14 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 9 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 13 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 5 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 5 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 7 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 8 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 8 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 9 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 15 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 11 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 12 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 11 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 9 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 14 times out of 20 for res 90000

=== w1064v1809_he (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 13 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 12 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 14 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 13 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 13 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 15 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 14 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 8 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 15 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 13 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 11 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 10 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 11 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 12 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 1 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 10 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 5 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 7 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 7 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 4 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 11 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 4 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 4 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 5 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 5 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 7 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 6 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 6 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 15 times out of 20 for res 90000

=== w1064v1809_ja (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 14 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 15 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 14 times out of 20 for res 60000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 12 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 15 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 12 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 6 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 14 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 6 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 9 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 5 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 5 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 5 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 6 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 3 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 13 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 12 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 9 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 10 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 7 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 12 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 15 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 9 times out of 20 for res 90000

=== w1064v1809_zh_CN (32 bit report) ===

ntdll:
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 13 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 13 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 13 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 14 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 15 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 14 times out of 20 for res 60000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 11 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 9 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 15 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 13 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 13 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 11 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 6 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 9 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 13 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 9 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 4 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 9 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 2 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 12 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 14 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 10 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 1 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 3 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 5 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 12 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 9 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 7 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 13 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 14 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 13 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 5 times out of 20 for res 90000

=== w2008s64 (64 bit report) ===

ntdll:
time.c:335: Test failed: resolution was set to 19531 which is not close to the requested one
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 1 times out of 20 for res 60000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 1 times out of 20 for res 60000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000

=== w864 (64 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000

=== w1064v1507 (64 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000

=== w1064v1809 (64 bit report) ===

ntdll:
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 13 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 13 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 15 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 14 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 15 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 15 times out of 20 for res 90000

=== debiant (32 bit report) ===

ntdll:
time.c:274: Test succeeded inside todo block: tick count isn't updated after sleeping one millisecond (99% correct)

=== debiant (32 bit French report) ===

ntdll:
time.c:274: Test succeeded inside todo block: tick count isn't updated after sleeping one millisecond (98% correct)

=== debiant (32 bit Japanese:Japan report) ===

ntdll:
time.c:274: Test succeeded inside todo block: tick count isn't updated after sleeping one millisecond (98% correct)

=== debiant (32 bit Chinese:China report) ===

ntdll:
time.c:274: Test succeeded inside todo block: tick count isn't updated after sleeping one millisecond (95% correct)

=== debiant (32 bit WoW report) ===

ntdll:
time.c:274: Test succeeded inside todo block: tick count isn't updated after sleeping one millisecond (98% correct)

=== debiant (64 bit WoW report) ===

ntdll:
time.c:274: Test succeeded inside todo block: tick count isn't updated after sleeping one millisecond (98% correct)

[PATCH 3/5] server: Set the worst case time for updating user_shared_data to 15ms

[Arkadiusz Hiler]

On windows ticks counts and other timestamps in user_shared_data seem to be
updated every 15.625ms, so let's err on the shorter side.

Signed-off-by: Arkadiusz Hiler 
---
 server/fd.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/fd.c b/server/fd.c
index 7ea8ac273e..1bdce6c70c 100644
--- a/server/fd.c
+++ b/server/fd.c
@@ -377,7 +377,7 @@ timeout_t current_time;
 timeout_t monotonic_time;

struct _KUSER_SHARED_DATA *user_shared_data = NULL;
-static const int user_shared_data_timeout = 16;
+static const int user_shared_data_timeout = 15;

static void set_user_shared_data_time(void)
 {

[PATCH 4/5] ntdll: Remove todo_wine from tick count vs sleep test

[Arkadiusz Hiler]

With the default timer resolution the tick count should get updated each
Sleep(1) after the recent changes.

Signed-off-by: Arkadiusz Hiler 
---
 dlls/ntdll/tests/time.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dlls/ntdll/tests/time.c b/dlls/ntdll/tests/time.c
index 0f4096f708..f0bd22abb8 100644
--- a/dlls/ntdll/tests/time.c
+++ b/dlls/ntdll/tests/time.c
@@ -271,7 +271,7 @@ static void test_user_shared_data_time(void)
         t2 = GetTickCount();
         if (t1 != t2) changed++;
     }
-    todo_wine ok(changed >= 90, "tick count isn't updated after sleeping one millisecond (%d%% correct)\n", changed);
+    ok(changed >= 90, "tick count isn't updated after sleeping one millisecond (%d%% correct)\n", changed);
 }

BOOL spin_the_thread = TRUE;

[PATCH 4/5] ntdll: Remove todo_wine from tick count vs sleep test

[Marvin]

Hi,

While running your changed tests, I think I found new failures.
Being a bot and all I'm not very good at pattern recognition, so I might be
wrong, but could you please double-check?

Full results can be found at:
https://testbot.winehq.org/JobDetails.pl?Key=77262

Your paranoid android.

=== w2008s64 (32 bit report) ===

ntdll:
time.c:335: Test failed: resolution was set to 19531 which is not close to the requested one
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 1 times out of 20 for res 60000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 1 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000

=== w8 (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000

=== w8adm (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000

=== w1064v1507 (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000

=== w1064v1809 (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 9 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 14 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 14 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 14 times out of 20 for res 90000

=== w1064v1809_2scr (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 14 times out of 20 for res 60000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 3 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 10 times out of 20 for res 60000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 11 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 14 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 15 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 14 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 12 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 12 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 10 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 15 times out of 20 for res 60000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 9 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 13 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 8 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 12 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 14 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 8 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 13 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 14 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 14 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 13 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 14 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 14 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 11 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 5 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 15 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 9 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 8 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 15 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 14 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 11 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 9 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 13 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 14 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 10 times out of 20 for res 90000

=== w1064v1809_ar (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 14 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 14 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 15 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 15 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 14 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 15 times out of 20 for res 90000

=== w1064v1809_he (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 14 times out of 20 for res 60000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 15 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 14 times out of 20 for res 60000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 12 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 13 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 12 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 13 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 14 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 11 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 12 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 12 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 6 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 9 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 14 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 6 times out of 20 for res 90000

=== w1064v1809_ja (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 15 times out of 20 for res 60000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 15 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 14 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 14 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 15 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 15 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 13 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 13 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 12 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 9 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 7 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 10 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 8 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 6 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 11 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 1 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 1 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 2 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 2 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 7 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 9 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 15 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 7 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 13 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 8 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 10 times out of 20 for res 90000

=== w1064v1809_zh_CN (32 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 15 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 14 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 14 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 13 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 13 times out of 20 for res 60000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 14 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 15 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 15 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 13 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 12 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 14 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 13 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 11 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 14 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 11 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 5 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 12 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 14 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 13 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 10 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 4 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 4 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 1 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 10 times out of 20 for res 90000

=== w2008s64 (64 bit report) ===

ntdll:
time.c:335: Test failed: resolution was set to 19531 which is not close to the requested one
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 1 times out of 20 for res 60000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000

=== w864 (64 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 60000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 60000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 60000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 90000

=== w1064v1507 (64 bit report) ===

ntdll:
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:354: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(TRUE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:361: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; NtDelayExecution(FALSE, &timeout); } hit the expected interval only 0 times out of 20 for res 30000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:372: Test failed: pNtWaitForSingleObject( thread, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:379: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:394: Test failed: { pNtSignalAndWaitForSingleObject( event, thread, TRUE, &timeout ); ResetEvent( event ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:408: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000
time.c:437: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 0 times out of 20 for res 30000

=== w1064v1809 (64 bit report) ===

ntdll:
time.c:323: Test failed: the default timer resolution is not set to the minimum
time.c:335: Test failed: resolution was set to 48828 which is not close to the requested one
time.c:338: Test failed: after unsetting we've got 24414 instead of the default 63476
time.c:346: Test failed: NtDelayExecution(TRUE, &timeout) hit the expected interval only 0 times out of 20 for res 30000
time.c:347: Test failed: NtDelayExecution(FALSE, &timeout) hit the expected interval only 0 times out of 20 for res 90000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:371: Test failed: pNtWaitForSingleObject( thread, TRUE, &timeout ) hit the expected interval only 13 times out of 20 for res 90000
time.c:386: Test failed: { NtQuerySystemTime(&timeout); timeout.QuadPart += 10000; pNtWaitForSingleObject( thread, FALSE, &timeout ); } hit the expected interval only 15 times out of 20 for res 90000
time.c:390: Test failed: pNtWaitForMultipleObjects( 1, &thread, TRUE, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 30000
time.c:406: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:407: Test failed: pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 0 times out of 20 for res 60000
time.c:409: Test failed: pNtReleaseKeyedEvent( event, (void *) 2, TRUE, &timeout ) hit the expected interval only 15 times out of 20 for res 90000
time.c:416: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 14 times out of 20 for res 90000
time.c:423: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtWaitForKeyedEvent( event, (void *) 2, TRUE, &timeout ); } hit the expected interval only 15 times out of 20 for res 90000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 15 times out of 20 for res 60000
time.c:430: Test failed: { NtQuerySystemTime( &timeout ); timeout.QuadPart += 10000; pNtReleaseKeyedEvent( event, (void *) 2, FALSE, &timeout ); } hit the expected interval only 14 times out of 20 for res 90000

[PATCH 5/5] winmm: Implement timeBeginPeriod() and timeEndPeriod()

[Arkadiusz Hiler]

On top of NtSetTimerResolution()...

missing: thread safety

Signed-off-by: Arkadiusz Hiler 
---
 dlls/winmm/tests/timer.c | 46 +++++++++++++++++++++++-
 dlls/winmm/time.c        | 76 +++++++++++++++++++++++++++++++++-------
 2 files changed, 109 insertions(+), 13 deletions(-)

diff --git a/dlls/winmm/tests/timer.c b/dlls/winmm/tests/timer.c
index be63f6b032..7619aa4a85 100644
--- a/dlls/winmm/tests/timer.c
+++ b/dlls/winmm/tests/timer.c
@@ -23,14 +23,19 @@
 #include <stdlib.h>
 #include <math.h>

-#include "wine/test.h"
+#include "ntstatus.h"
+#define WIN32_NO_STATUS
+#define NONAMELESSUNION
 #include "windef.h"
 #include "winbase.h"
+#include "winternl.h"
 #include "winnls.h"
 #include "mmsystem.h"
 #define NOBITMAP
 #include "mmreg.h"

+#include "wine/test.h"
+
 #include "winmm_test.h"

static TIMECAPS tc;
@@ -75,6 +80,43 @@ static void CALLBACK testTimeProc(UINT uID, UINT uMsg, DWORD_PTR dwUser,
         times[count++] = timeGetTime();
 }

+static void test_setting_resolution(void)
+{
+    ULONG min, max, cur;
+
+    ok(timeEndPeriod(5) == TIMERR_NOCANDO, "succeded to end period even though we haven't begun it\n");
+    ok(timeBeginPeriod(0) == TIMERR_NOCANDO, "succeded to start illegal 0 period\n");
+    ok(timeEndPeriod(17) == TIMERR_NOERROR, "failed to end period out of 1-15 range (it should always succeed)\n");
+
+    ok(timeBeginPeriod(10) == TIMERR_NOERROR, "failed to begin a period\n");
+    ok(NtQueryTimerResolution(&min, &max, &cur) == STATUS_SUCCESS, "failed to query timer resolution\n");
+    ok(cur <= 100000 && cur >= 50000, "resolution hasn't changed to the desired one\n");
+
+    ok(timeBeginPeriod(5) == TIMERR_NOERROR, "failed to begin a period\n");
+    ok(timeBeginPeriod(4) == TIMERR_NOERROR, "failed to begin a period\n");
+    ok(timeBeginPeriod(3) == TIMERR_NOERROR, "failed to begin a period\n");
+    ok(NtQueryTimerResolution(&min, &max, &cur) == STATUS_SUCCESS, "failed to query timer resolution\n");
+    ok(cur <= 30000, "resolution hasn't changed to the desired one\n");
+
+    ok(timeEndPeriod(3) == TIMERR_NOERROR, "failed to end a period\n");
+    ok(timeEndPeriod(4) == TIMERR_NOERROR, "failed to end a period 4 out of order\n");
+    ok(timeEndPeriod(5) == TIMERR_NOERROR, "failed to end a period\n");
+    ok(NtQueryTimerResolution(&min, &max, &cur) == STATUS_SUCCESS, "failed to query timer resolution\n");
+    ok(cur <= 100000 && cur >= 50000, "resolution hasn't changed to the desired one\n");
+
+    ok(timeEndPeriod(10) == TIMERR_NOERROR, "failed to end a period 7 out of order\n");
+
+    ok(NtQueryTimerResolution(&min, &max, &cur) == STATUS_SUCCESS, "failed to query timer resolution\n");
+    ok(cur == min, "resolution is not back to default after ending all periods\n");
+
+    ok(timeBeginPeriod(16) == TIMERR_NOERROR, "failed to begin a period outside of 1-15 range\n");
+
+    /* 16 is out of 1-15 range, so it should have no effect */
+    ok(NtSetTimerResolution(0, FALSE, &cur) == STATUS_TIMER_RESOLUTION_NOT_SET, "succeded to reset timer resolution even though it wasn't set\n");
+
+    ok(timeEndPeriod(3) == TIMERR_NOCANDO, "succeded to end period without matching begin\n");
+}
+
 static void test_timer(UINT period, UINT resolution)
 {
     MMRESULT rc;
@@ -197,6 +239,8 @@ START_TEST(timer)
 {
     test_timeGetDevCaps();

+    test_setting_resolution();
+
     if (tc.wPeriodMin <= 1) {
         test_timer(1, 0);
         test_timer(1, 1);
diff --git a/dlls/winmm/time.c b/dlls/winmm/time.c
index bdf4983c47..740ea7db58 100644
--- a/dlls/winmm/time.c
+++ b/dlls/winmm/time.c
@@ -23,9 +23,14 @@
 #include <stdarg.h>
 #include <errno.h>
 #include <time.h>
+#include <limits.h>

+#include "ntstatus.h"
+#define WIN32_NO_STATUS
+#define NONAMELESSUNION
 #include "windef.h"
 #include "winbase.h"
+#include "winternl.h"
 #include "mmsystem.h"

#include "winemm.h"
@@ -386,20 +391,44 @@ MMRESULT WINAPI timeGetDevCaps(LPTIMECAPS lpCaps, UINT wSize)
     return TIMERR_NOERROR;
 }

+extern NTSYSAPI NTSTATUS NTAPI NtSetTimerResolution(ULONG DesiredResolution, BOOLEAN SetResolution, PULONG CurrentResolution);
+
+/* Windows seem to allow to set each resolution betwen 1 and 15 exactly 65535 times before complaining*/
+static USHORT timer_request_count[15]; /* TODO: locking */
+
 /**************************************************************************
  * 				timeBeginPeriod		[WINMM.@]
  */
 MMRESULT WINAPI timeBeginPeriod(UINT wPeriod)
 {
-    if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
-	return TIMERR_NOCANDO;
+    NTSTATUS ret;
+    ULONG cur;
+    ULONG resolution = 0;

-    if (wPeriod > MMSYSTIME_MININTERVAL)
-    {
-        WARN("Stub; we set our timer resolution at minimum\n");
+    if (wPeriod == 0) /* illegal */
+        return TIMERR_NOCANDO;
+
+    if (wPeriod > 15) /* 16+ is more than the default 15.6ms - we don't even care */
+        return TIMERR_NOERROR;
+
+    if (timer_request_count[wPeriod] == USHRT_MAX)
+        return TIMERR_NOCANDO;
+
+    timer_request_count[wPeriod]++;
+
+    for (int i = 0; i < ARRAYSIZE(timer_request_count); i++) {
+        if (timer_request_count[i] != 0) {
+            resolution = i * 10000;
+            break;
+        }
     }

-    return 0;
+    ret = NtSetTimerResolution(resolution, TRUE, &cur);
+
+    if (ret == STATUS_SUCCESS)
+        return TIMERR_NOERROR;
+    else
+        return TIMERR_NOCANDO;
 }

/**************************************************************************
@@ -407,12 +436,35 @@ MMRESULT WINAPI timeBeginPeriod(UINT wPeriod)
  */
 MMRESULT WINAPI timeEndPeriod(UINT wPeriod)
 {
-    if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
-	return TIMERR_NOCANDO;
+    ULONG cur;
+    ULONG resolution = 0;
+    NTSTATUS ret;

-    if (wPeriod > MMSYSTIME_MININTERVAL)
-    {
-        WARN("Stub; we set our timer resolution at minimum\n");
+    if (wPeriod == 0)
+        return TIMERR_NOCANDO;
+
+    if (wPeriod > 15)
+        return TIMERR_NOERROR;
+
+    if (timer_request_count[wPeriod] == 0)
+        return TIMERR_NOCANDO;
+
+    timer_request_count[wPeriod]--;
+
+    for (int i = 0; i < ARRAYSIZE(timer_request_count); i++) {
+        if (timer_request_count[i] != 0) {
+            resolution = i * 10000;
+            break;
+        }
     }
-    return 0;
+
+    if (resolution)
+        ret = NtSetTimerResolution(resolution, TRUE, &cur);
+    else
+        ret = NtSetTimerResolution(resolution, FALSE, &cur);
+
+    if (ret == STATUS_SUCCESS)
+        return TIMERR_NOERROR;
+    else
+        return TIMERR_NOCANDO;
 }

[PATCH 5/5] winmm: Implement timeBeginPeriod() and timeEndPeriod()

[Marvin]

Hi,

While running your changed tests, I think I found new failures.
Being a bot and all I'm not very good at pattern recognition, so I might be
wrong, but could you please double-check?

Full results can be found at:
https://testbot.winehq.org/JobDetails.pl?Key=77263

Your paranoid android.

=== w1064v1809 (32 bit report) ===

winmm:
timer.c:93: Test failed: resolution hasn't changed to the desired one
timer.c:110: Test failed: resolution is not back to default after ending all periods

=== w1064v1809_2scr (32 bit report) ===

winmm:
timer.c:93: Test failed: resolution hasn't changed to the desired one
timer.c:105: Test failed: resolution hasn't changed to the desired one
timer.c:110: Test failed: resolution is not back to default after ending all periods

=== w1064v1809 (64 bit report) ===

winmm:
timer.c:110: Test failed: resolution is not back to default after ending all periods

[Rémi Bernon]

On 2020-08-17 19:46, Arkadiusz Hiler wrote:
> TL;DR: Good learning experience, lead to a fix in winmm but IMO we are better
>         off defaulting to 1ms resolution and avoid all the extra complications.
>
> The whole thing started because of miss-assigning blame for DOSBox regression
> to mismatched GetTickCount() and Sleep() resolutions. Initial attempts at
> fixing the issue just made Sleep() work in increments of 15.6ms.
>
> Then, I have learned about timer resolution and I have started implementing
> this series. As soon as I had working timeBeginPeriod() DOSBox regressed
> again.
>
> After some confusing debugging of "phantom" calls to GetTickCount() with
> 1-call stacktraces and building myself and unoptimized debug version of SDL
> and DOSBox I have found out that, in Wine, timeGetTime() is an alias for
> GetTickCount() and this has caused the problem.
>
> More details here: https://www.winehq.org/pipermail/wine-devel/2020-August/171965.html
>
> I have started questioning usefulness and feasibility of implementing
> resolution support:
> - introducing extra branching for each Sleep / Wait call
> - multiple places to maintain (some wait calls use server_wait, other call server directly)
> - a lot of Sleep(1) to assess across Wine's codebase
> - per-process implementation may be not sufficient for some multi-process software
>
> I did testing with popular software and a lot of things set resolution:
> - Chrome and a lot of Electron-based apps - 1ms with multimedia content,
>                                           fluctuating otherwise
> - Firefox - 8ms when downloading, 5ms when playing music/videos
> - Visual Studio - 1ms all the time
> - Discord - 1ms all the time while being on a voice chat
> - Spotify - oscillating 1-5ms when playing music
> - EGS - 1ms
> - many many games
>
> Resolution is global - if one process requests high resolution (i.e. low
> update interval) the whole system gets it.
>
> Conjecture: If having 1ms resolution all the time / by default would cause any
> noticeable problems / performance issue with software, it would be seen on
> Windows and loudly complained about.
>
> I think it's worth abandoning the effort to implement proper resolution
> setting, default to 1ms and implement more convincing stubs for
> timeBeginPeriod() and NtSetTimerResolution() and friends.
>
> Any thoughts?
>
> Cc: Rémi Bernon 
> Cc: Paul Gofman
>
> Arkadiusz Hiler (5):
>    ntdll: Implmement NtQueryTimerResolution and NtSetTimerResolution
>    ntdll: Make wait/delay calls respect the timer resolution
>    server: Set the worst case time for updating user_shared_data to 15ms
>    ntdll: Remove todo_wine from tick count vs sleep test
>    winmm: Implement timeBeginPeriod() and timeEndPeriod()
>
> dlls/ntdll/tests/time.c        | 187 ++++++++++++++++++++++++++++++++-
>   dlls/ntdll/unix/server.c       |  16 ++-
>   dlls/ntdll/unix/sync.c         |  84 +++++++++++++--
>   dlls/ntdll/unix/unix_private.h |  10 ++
>   dlls/winmm/tests/timer.c       |  46 +++++++-
>   dlls/winmm/time.c              |  76 +++++++++++---
>   server/fd.c                    |   2 +-
>   7 files changed, 396 insertions(+), 25 deletions(-)

I think that if it adds such complexity just for the sake of better 
mimicing Windows, and without actually fixing anything, it may indeed 
not be worth it. If and when we find an application that is broken by 
this behavior then maybe we could reconsider it.

Then IIRC the DOSBOX issue is just about winmm and its assumptions that 
GetTickCount resolution is 1ms on Wine, which is now incorrect. But it 
is also incorrect on Windows too, regardless of this resolution thing 
right? So that definitely needs a fix.

[Arkadiusz Hiler]

On Tue, Aug 18, 2020 at 11:38:49AM +0200, Rémi Bernon wrote:
> On 2020-08-17 19:46, Arkadiusz Hiler wrote:
> > TL;DR: Good learning experience, lead to a fix in winmm but IMO we are better
> >         off defaulting to 1ms resolution and avoid all the extra complications.

<SNIP>
> I think that if it adds such complexity just for the sake of better mimicing
> Windows, and without actually fixing anything, it may indeed not be worth
> it. If and when we find an application that is broken by this behavior then
> maybe we could reconsider it.

Judging by the number of programs that are setting 1ms resolution, if it
a piece of software would be broken, it would be also broken on Windows,
so I don't think it's very likely we will ever get there.
> Then IIRC the DOSBOX issue is just about winmm and its assumptions that
> GetTickCount resolution is 1ms on Wine, which is now incorrect. But it is
> also incorrect on Windows too, regardless of this resolution thing right? So
> that definitely needs a fix.

The DOSBox problem was Wine aliasing timeGetTime() to GetTickCount()
on the assumption that GetTickCount() is 1ms-accurate.

DOSBox is using timeGetTime() and timeBeginPeriod().

There's a patch that fixes this by implementing timeGetTime() on top of
QueryPerformanceCounter().

https://www.winehq.org/pipermail/wine-devel/2020-August/171965.html

Going back to defaulting to 1ms resolution, I think I'll just write tests that:

TIMERR_NOERROR == timeBeginPeriod(1); /* for Windows */
  HAS_1MS_RESOLUTION(Sleep(1)); /* for Wait*() and other calls that we know are affected */
  HAS_INCREMENT_OF_1(timeGetTime());
  ...

Also, we could stub NtQueryTimerResolution() to return the same values
as Win10 after timeBeginPeriod(1). This is not solving any real
bugs, but may save some hassle the next person going down the timer
resolution lane:

diff --git a/dlls/ntdll/unix/sync.c b/dlls/ntdll/unix/sync.c
index 23dca9c61b..2743b17e54 100644
--- a/dlls/ntdll/unix/sync.c
+++ b/dlls/ntdll/unix/sync.c
@@ -81,6 +81,9 @@ static const LARGE_INTEGER zero_timeout;

static pthread_mutex_t addr_mutex = PTHREAD_MUTEX_INITIALIZER;

+static ULONG timer_resolution_min = 156250;
+static ULONG timer_resolution_max = 5000;
+
 /* return a monotonic time counter, in Win32 ticks */
 static inline ULONGLONG monotonic_counter(void)
 {
@@ -1438,8 +1441,15 @@ NTSTATUS WINAPI NtSetSystemTime( const LARGE_INTEGER *new, LARGE_INTEGER *old )
  */
 NTSTATUS WINAPI NtQueryTimerResolution( ULONG *min_res, ULONG *max_res, ULONG *current_res )
 {
-    FIXME( "(%p,%p,%p), stub!\n", min_res, max_res, current_res );
-    return STATUS_NOT_IMPLEMENTED;
+    TRACE( "(%p,%p,%p)\n", min_res, max_res, current_res );
+
+    if (!min_res || !max_res || !current_res) return STATUS_ACCESS_VIOLATION;
+
+    *min_res = timer_resolution_min;
+    *max_res = timer_resolution_max;
+    *current_res = timer_resolution_max;
+
+    return STATUS_SUCCESS;
 }

@@ -1448,8 +1458,13 @@ NTSTATUS WINAPI NtQueryTimerResolution( ULONG *min_res, ULONG *max_res, ULONG *c
  */
 NTSTATUS WINAPI NtSetTimerResolution( ULONG res, BOOLEAN set, ULONG *current_res )
 {
-    FIXME( "(%u,%u,%p), stub!\n", res, set, current_res );
-    return STATUS_NOT_IMPLEMENTED;
+    TRACE( "(%u,%u,%p)\n", res, set, current_res );
+
+    if (!current_res) return STATUS_ACCESS_VIOLATION;
+
+    *current_res = timer_resolution_max;
+
+    return STATUS_SUCCESS;
 }