mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-09-26 18:29:57 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 10

Merge latest Tulip into asyncio

Browse source 
- Make the new granularity attribute private
- Simplify BaseEventLoop._run_once(): avoid math.ceil(), use simple arithmetic
  instead
This commit is contained in:
Victor Stinner 2014-01-26 00:02:31 +01:00
parent 3c2f175ec4
commit 669eeaf933
4 changed files with 5 additions and 16 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Doc/library/asyncio-eventloop.rst
View file

@ -144,12 +144,6 @@ a different clock than :func:`time.time`.
Return the current time, as a :class:`float` value, according to the Return the current time, as a :class:`float` value, according to the
event loop's internal clock. event loop's internal clock.
.. attribute:: BaseEventLoop.granularity
Granularity of the time: maximum between the resolution of the
:meth:`BaseEventLoop.time` method and the resolution of the selector (see
:attr:`selectors.BaseSelector.resolution`).
.. seealso:: .. seealso::
The :func:`asyncio.sleep` function. The :func:`asyncio.sleep` function.

9
Lib/asyncio/base_events.py
View file

@ -18,7 +18,6 @@ import collections
import concurrent.futures import concurrent.futures
import heapq import heapq
import logging import logging
import math
import socket import socket
import subprocess import subprocess
import time import time
@ -97,7 +96,7 @@ class BaseEventLoop(events.AbstractEventLoop):
self._default_executor = None self._default_executor = None
self._internal_fds = 0 self._internal_fds = 0
self._running = False self._running = False
self.granularity = time.get_clock_info('monotonic').resolution self._granularity = time.get_clock_info('monotonic').resolution
def _make_socket_transport(self, sock, protocol, waiter=None, *, def _make_socket_transport(self, sock, protocol, waiter=None, *,
extra=None, server=None): extra=None, server=None):
@ -605,8 +604,6 @@ class BaseEventLoop(events.AbstractEventLoop):
elif self._scheduled: elif self._scheduled:
# Compute the desired timeout. # Compute the desired timeout.
when = self._scheduled[0]._when when = self._scheduled[0]._when
# round deadline aways from zero
when = math.ceil(when / self.granularity) * self.granularity
deadline = max(0, when - self.time()) deadline = max(0, when - self.time())
if timeout is None: if timeout is None:
timeout = deadline timeout = deadline
@ -632,9 +629,7 @@ class BaseEventLoop(events.AbstractEventLoop):
self._process_events(event_list) self._process_events(event_list)
# Handle 'later' callbacks that are ready. # Handle 'later' callbacks that are ready.
now = self.time() now = self.time() + self._granularity
# round current time aways from zero
now = math.ceil(now / self.granularity) * self.granularity
while self._scheduled: while self._scheduled:
handle = self._scheduled[0] handle = self._scheduled[0]
if handle._when > now: if handle._when > now:

2
Lib/asyncio/selector_events.py
View file

@ -36,7 +36,7 @@ class BaseSelectorEventLoop(base_events.BaseEventLoop):
selector = selectors.DefaultSelector() selector = selectors.DefaultSelector()
logger.debug('Using selector: %s', selector.__class__.__name__) logger.debug('Using selector: %s', selector.__class__.__name__)
self._selector = selector self._selector = selector
self.granularity = max(selector.resolution, self.granularity) self._granularity = max(selector.resolution, self._granularity)
self._make_self_pipe() self._make_self_pipe()
def _make_socket_transport(self, sock, protocol, waiter=None, *, def _make_socket_transport(self, sock, protocol, waiter=None, *,

4
Lib/test/test_asyncio/test_events.py
View file

@ -1170,9 +1170,9 @@ class EventLoopTestsMixin:
def wait(): def wait():
loop = self.loop loop = self.loop
calls.append(loop._run_once_counter) calls.append(loop._run_once_counter)
yield from asyncio.sleep(loop.granularity * 10, loop=loop) yield from asyncio.sleep(loop._granularity * 10, loop=loop)
calls.append(loop._run_once_counter) calls.append(loop._run_once_counter)
yield from asyncio.sleep(loop.granularity / 10, loop=loop) yield from asyncio.sleep(loop._granularity / 10, loop=loop)
calls.append(loop._run_once_counter) calls.append(loop._run_once_counter)
self.loop.run_until_complete(wait()) self.loop.run_until_complete(wait())