def do_poll(self, space, timeout):
from pypy.module._multiprocessing.interp_win32 import (
_PeekNamedPipe, _GetTickCount, _Sleep)
from rpython.rlib import rwin32
from pypy.interpreter.error import wrap_windowserror
bytes_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO, 1,
flavor='raw')
try:
if not _PeekNamedPipe(self.handle, rffi.NULL, 0,
lltype.nullptr(rwin32.LPDWORD.TO),
bytes_ptr,
lltype.nullptr(rwin32.LPDWORD.TO)):
raise wrap_windowserror(space, rwin32.lastSavedWindowsError())
bytes = bytes_ptr[0]
finally:
lltype.free(bytes_ptr, flavor='raw')
if timeout == 0.0:
return bytes > 0
block = timeout < 0
if not block:
# XXX does not check for overflow
deadline = intmask(_GetTickCount()) + int(1000 * timeout + 0.5)
else:
deadline = 0
_Sleep(0)
delay = 1
while True:
bytes_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO, 1,
flavor='raw')
try:
if not _PeekNamedPipe(self.handle, rffi.NULL, 0,
lltype.nullptr(rwin32.LPDWORD.TO),
bytes_ptr,
lltype.nullptr(rwin32.LPDWORD.TO)):
raise wrap_windowserror(space,
rwin32.lastSavedWindowsError())
bytes = bytes_ptr[0]
finally:
lltype.free(bytes_ptr, flavor='raw')
if bytes > 0:
return True
if not block:
now = intmask(_GetTickCount())
if now > deadline:
return False
diff = deadline - now
if delay > diff:
delay = diff
else:
delay += 1
if delay >= 20:
delay = 20
_Sleep(delay)
def semlock_acquire(self, space, block, w_timeout):
if not block:
full_msecs = 0
elif space.is_none(w_timeout):
full_msecs = rwin32.INFINITE
else:
timeout = space.float_w(w_timeout)
timeout *= 1000.0
if timeout < 0.0:
timeout = 0.0
elif timeout >= 0.5 * rwin32.INFINITE: # 25 days
raise oefmt(space.w_OverflowError, "timeout is too large")
full_msecs = r_uint(int(timeout + 0.5))
# check whether we can acquire without blocking
res = rwin32.WaitForSingleObject(self.handle, 0)
if res != rwin32.WAIT_TIMEOUT:
self.last_tid = rthread.get_ident()
self.count += 1
return True
msecs = full_msecs
start = _GetTickCount()
while True:
from pypy.module.time.interp_time import State
interrupt_event = space.fromcache(State).get_interrupt_event()
handles = [self.handle, interrupt_event]
# do the wait
rwin32.ResetEvent(interrupt_event)
res = rwin32.WaitForMultipleObjects(handles, timeout=msecs)
if res != rwin32.WAIT_OBJECT_0 + 1:
break
# got SIGINT so give signal handler a chance to run
time.sleep(0.001)
# if this is main thread let KeyboardInterrupt be raised
_check_signals(space)
# recalculate timeout
if msecs != rwin32.INFINITE:
ticks = _GetTickCount()
if r_uint(ticks - start) >= full_msecs:
return False
msecs = full_msecs - r_uint(ticks - start)
# handle result
if res != rwin32.WAIT_TIMEOUT:
self.last_tid = rthread.get_ident()
self.count += 1
return True
return False
def semlock_acquire(self, space, block, w_timeout):
if not block:
full_msecs = 0
elif space.is_none(w_timeout):
full_msecs = rwin32.INFINITE
else:
timeout = space.float_w(w_timeout)
timeout *= 1000.0
if timeout < 0.0:
timeout = 0.0
elif timeout >= 0.5 * rwin32.INFINITE: # 25 days
raise OperationError(space.w_OverflowError,
space.wrap("timeout is too large"))
full_msecs = r_uint(int(timeout + 0.5))
# check whether we can acquire without blocking
res = rwin32.WaitForSingleObject(self.handle, 0)
if res != rwin32.WAIT_TIMEOUT:
return True
msecs = full_msecs
start = _GetTickCount()
while True:
from pypy.module.time.interp_time import State
interrupt_event = space.fromcache(State).get_interrupt_event()
handles = [self.handle, interrupt_event]
# do the wait
rwin32.ResetEvent(interrupt_event)
res = rwin32.WaitForMultipleObjects(handles, timeout=msecs)
if res != rwin32.WAIT_OBJECT_0 + 1:
break
# got SIGINT so give signal handler a chance to run
time.sleep(0.001)
# if this is main thread let KeyboardInterrupt be raised
_check_signals(space)
# recalculate timeout
if msecs != rwin32.INFINITE:
ticks = _GetTickCount()
if r_uint(ticks - start) >= full_msecs:
return False
msecs = full_msecs - r_uint(ticks - start)
# handle result
if res != rwin32.WAIT_TIMEOUT:
return True
return False
def do_poll(self, space, timeout):
from pypy.module._multiprocessing.interp_win32 import (_PeekNamedPipe,
_GetTickCount,
_Sleep)
from rpython.rlib import rwin32
from pypy.interpreter.error import wrap_windowserror
bytes_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO,
1,
flavor='raw')
try:
if not _PeekNamedPipe(self.handle, rffi.NULL, 0,
lltype.nullptr(rwin32.LPDWORD.TO), bytes_ptr,
lltype.nullptr(rwin32.LPDWORD.TO)):
raise wrap_windowserror(space, rwin32.lastSavedWindowsError())
bytes = bytes_ptr[0]
finally:
lltype.free(bytes_ptr, flavor='raw')
if timeout == 0.0:
return bytes > 0
block = timeout < 0
if not block:
# XXX does not check for overflow
deadline = intmask(_GetTickCount()) + int(1000 * timeout + 0.5)
else:
deadline = 0
_Sleep(0)
delay = 1
while True:
bytes_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO,
1,
flavor='raw')
try:
if not _PeekNamedPipe(self.handle, rffi.NULL, 0,
lltype.nullptr(rwin32.LPDWORD.TO),
bytes_ptr,
lltype.nullptr(rwin32.LPDWORD.TO)):
raise wrap_windowserror(space,
rwin32.lastSavedWindowsError())
bytes = bytes_ptr[0]
finally:
lltype.free(bytes_ptr, flavor='raw')
if bytes > 0:
return True
if not block:
now = intmask(_GetTickCount())
if now > deadline:
return False
diff = deadline - now
if delay > diff:
delay = diff
else:
delay += 1
if delay >= 20:
delay = 20
_Sleep(delay)
