Merge pull request #4400 from jonahkichwacoders/remove_5s_wait

Remove 5s wait on inactivity on GUI inputhook loops

1s should be enough

IPython/lib/inputhookglut.py

@@ -1,175 +1,172 b''
 # coding: utf-8
 """
 GLUT Inputhook support functions
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 # GLUT is quite an old library and it is difficult to ensure proper
 # integration within IPython since original GLUT does not allow to handle
 # events one by one. Instead, it requires for the mainloop to be entered
 # and never returned (there is not even a function to exit he
 # mainloop). Fortunately, there are alternatives such as freeglut
 # (available for linux and windows) and the OSX implementation gives
 # access to a glutCheckLoop() function that blocks itself until a new
 # event is received. This means we have to setup the idle callback to
 # ensure we got at least one event that will unblock the function.
 #
 # Furthermore, it is not possible to install these handlers without a window
 # being first created. We choose to make this window invisible. This means that
 # display mode options are set at this level and user won't be able to change
 # them later without modifying the code. This should probably be made available
 # via IPython options system.
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 import os
 import sys
 import time
 import signal
 import OpenGL.GLUT as glut
 import OpenGL.platform as platform
 from timeit import default_timer as clock
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 # Frame per second : 60
 # Should probably be an IPython option
 glut_fps = 60
 
 
 # Display mode : double buffeed + rgba + depth
 # Should probably be an IPython option
 glut_display_mode = (glut.GLUT_DOUBLE |
                      glut.GLUT_RGBA   |
                      glut.GLUT_DEPTH)
 
 glutMainLoopEvent = None
 if sys.platform == 'darwin':
     try:
         glutCheckLoop = platform.createBaseFunction(
             'glutCheckLoop', dll=platform.GLUT, resultType=None,
             argTypes=[],
             doc='glutCheckLoop(  ) -> None',
             argNames=(),
             )
     except AttributeError:
         raise RuntimeError(
             '''Your glut implementation does not allow interactive sessions'''
             '''Consider installing freeglut.''')
     glutMainLoopEvent = glutCheckLoop
 elif glut.HAVE_FREEGLUT:
     glutMainLoopEvent = glut.glutMainLoopEvent
 else:
     raise RuntimeError(
         '''Your glut implementation does not allow interactive sessions. '''
         '''Consider installing freeglut.''')
 
 
 #-----------------------------------------------------------------------------
 # Platform-dependent imports and functions
 #-----------------------------------------------------------------------------
 
 if os.name == 'posix':
     import select
 
     def stdin_ready():
         infds, outfds, erfds = select.select([sys.stdin],[],[],0)
         if infds:
             return True
         else:
             return False
 
 elif sys.platform == 'win32':
     import msvcrt
 
     def stdin_ready():
         return msvcrt.kbhit()
 
 #-----------------------------------------------------------------------------
 # Callback functions
 #-----------------------------------------------------------------------------
 
 def glut_display():
     # Dummy display function
     pass
 
 def glut_idle():
     # Dummy idle function
     pass
 
 def glut_close():
     # Close function only hides the current window
     glut.glutHideWindow()
     glutMainLoopEvent()
 
 def glut_int_handler(signum, frame):
     # Catch sigint and print the defautl message
     signal.signal(signal.SIGINT, signal.default_int_handler)
     print '\nKeyboardInterrupt'
     # Need to reprint the prompt at this stage
 
 
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 def inputhook_glut():
     """Run the pyglet event loop by processing pending events only.
 
     This keeps processing pending events until stdin is ready.  After
     processing all pending events, a call to time.sleep is inserted.  This is
     needed, otherwise, CPU usage is at 100%.  This sleep time should be tuned
     though for best performance.
     """
     # We need to protect against a user pressing Control-C when IPython is
     # idle and this is running. We trap KeyboardInterrupt and pass.
 
     signal.signal(signal.SIGINT, glut_int_handler)
 
     try:
         t = clock()
 
         # Make sure the default window is set after a window has been closed
         if glut.glutGetWindow() == 0:
             glut.glutSetWindow( 1 )
             glutMainLoopEvent()
             return 0
 
         while not stdin_ready():
             glutMainLoopEvent()
             # We need to sleep at this point to keep the idle CPU load
             # low.  However, if sleep to long, GUI response is poor.  As
             # a compromise, we watch how often GUI events are being processed
             # and switch between a short and long sleep time.  Here are some
             # stats useful in helping to tune this.
             # time    CPU load
             # 0.001   13%
             # 0.005   3%
             # 0.01    1.5%
             # 0.05    0.5%
             used_time = clock() - t
-            if used_time > 5*60.0:
-                # print 'Sleep for 5 s'  # dbg
-                time.sleep(5.0)
-            elif used_time > 10.0:
+            if used_time > 10.0:
                 # print 'Sleep for 1 s'  # dbg
                 time.sleep(1.0)
             elif used_time > 0.1:
                 # Few GUI events coming in, so we can sleep longer
                 # print 'Sleep for 0.05 s'  # dbg
                 time.sleep(0.05)
             else:
                 # Many GUI events coming in, so sleep only very little
                 time.sleep(0.001)
     except KeyboardInterrupt:
         pass
     return 0

IPython/lib/inputhookpyglet.py

@@ -1,114 +1,111 b''
 # encoding: utf-8
 """
 Enable pyglet to be used interacive by setting PyOS_InputHook.
 
 Authors
 -------
 
 * Nicolas P. Rougier
 * Fernando Perez
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import sys
 import time
 from timeit import default_timer as clock
 import pyglet
 
 #-----------------------------------------------------------------------------
 # Platform-dependent imports and functions
 #-----------------------------------------------------------------------------
 
 if os.name == 'posix':
     import select
 
     def stdin_ready():
         infds, outfds, erfds = select.select([sys.stdin],[],[],0)
         if infds:
             return True
         else:
             return False
 
 elif sys.platform == 'win32':
     import msvcrt
 
     def stdin_ready():
         return msvcrt.kbhit()
 
 
 # On linux only, window.flip() has a bug that causes an AttributeError on
 # window close.  For details, see:
 # http://groups.google.com/group/pyglet-users/browse_thread/thread/47c1aab9aa4a3d23/c22f9e819826799e?#c22f9e819826799e
 
 if sys.platform.startswith('linux'):
     def flip(window):
         try:
             window.flip()
         except AttributeError:
             pass
 else:
     def flip(window):
         window.flip()
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 def inputhook_pyglet():
     """Run the pyglet event loop by processing pending events only.
 
     This keeps processing pending events until stdin is ready.  After
     processing all pending events, a call to time.sleep is inserted.  This is
     needed, otherwise, CPU usage is at 100%.  This sleep time should be tuned
     though for best performance.
     """
     # We need to protect against a user pressing Control-C when IPython is
     # idle and this is running. We trap KeyboardInterrupt and pass.
     try:
         t = clock()
         while not stdin_ready():
             pyglet.clock.tick()
             for window in pyglet.app.windows:
                 window.switch_to()
                 window.dispatch_events()
                 window.dispatch_event('on_draw')
                 flip(window)
 
             # We need to sleep at this point to keep the idle CPU load
             # low.  However, if sleep to long, GUI response is poor.  As
             # a compromise, we watch how often GUI events are being processed
             # and switch between a short and long sleep time.  Here are some
             # stats useful in helping to tune this.
             # time    CPU load
             # 0.001   13%
             # 0.005   3%
             # 0.01    1.5%
             # 0.05    0.5%
             used_time = clock() - t
-            if used_time > 5*60.0:
-                # print 'Sleep for 5 s'  # dbg
-                time.sleep(5.0)
-            elif used_time > 10.0:
+            if used_time > 10.0:
                 # print 'Sleep for 1 s'  # dbg
                 time.sleep(1.0)
             elif used_time > 0.1:
                 # Few GUI events coming in, so we can sleep longer
                 # print 'Sleep for 0.05 s'  # dbg
                 time.sleep(0.05)
             else:
                 # Many GUI events coming in, so sleep only very little
                 time.sleep(0.001)
     except KeyboardInterrupt:
         pass
     return 0

IPython/lib/inputhookwx.py

@@ -1,170 +1,167 b''
 # encoding: utf-8
 
 """
 Enable wxPython to be used interacive by setting PyOS_InputHook.
 
 Authors:  Robin Dunn, Brian Granger, Ondrej Certik
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import sys
 import signal
 import time
 from timeit import default_timer as clock
 import wx
 
 from IPython.lib.inputhook import stdin_ready
 
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 def inputhook_wx1():
     """Run the wx event loop by processing pending events only.
 
     This approach seems to work, but its performance is not great as it
     relies on having PyOS_InputHook called regularly.
     """
     try:
         app = wx.GetApp()
         if app is not None:
             assert wx.Thread_IsMain()
 
             # Make a temporary event loop and process system events until
             # there are no more waiting, then allow idle events (which
             # will also deal with pending or posted wx events.)
             evtloop = wx.EventLoop()
             ea = wx.EventLoopActivator(evtloop)
             while evtloop.Pending():
                 evtloop.Dispatch()
             app.ProcessIdle()
             del ea
     except KeyboardInterrupt:
         pass
     return 0
 
 class EventLoopTimer(wx.Timer):
 
     def __init__(self, func):
         self.func = func
         wx.Timer.__init__(self)
 
     def Notify(self):
         self.func()
 
 class EventLoopRunner(object):
 
     def Run(self, time):
         self.evtloop = wx.EventLoop()
         self.timer = EventLoopTimer(self.check_stdin)
         self.timer.Start(time)
         self.evtloop.Run()
 
     def check_stdin(self):
         if stdin_ready():
             self.timer.Stop()
             self.evtloop.Exit()
 
 def inputhook_wx2():
     """Run the wx event loop, polling for stdin.
 
     This version runs the wx eventloop for an undetermined amount of time,
     during which it periodically checks to see if anything is ready on
     stdin.  If anything is ready on stdin, the event loop exits.
 
     The argument to elr.Run controls how often the event loop looks at stdin.
     This determines the responsiveness at the keyboard.  A setting of 1000
     enables a user to type at most 1 char per second.  I have found that a
     setting of 10 gives good keyboard response.  We can shorten it further,
     but eventually performance would suffer from calling select/kbhit too
     often.
     """
     try:
         app = wx.GetApp()
         if app is not None:
             assert wx.Thread_IsMain()
             elr = EventLoopRunner()
             # As this time is made shorter, keyboard response improves, but idle
             # CPU load goes up.  10 ms seems like a good compromise.
             elr.Run(time=10)  # CHANGE time here to control polling interval
     except KeyboardInterrupt:
         pass
     return 0
 
 def inputhook_wx3():
     """Run the wx event loop by processing pending events only.
 
     This is like inputhook_wx1, but it keeps processing pending events
     until stdin is ready.  After processing all pending events, a call to
     time.sleep is inserted.  This is needed, otherwise, CPU usage is at 100%.
     This sleep time should be tuned though for best performance.
     """
     # We need to protect against a user pressing Control-C when IPython is
     # idle and this is running. We trap KeyboardInterrupt and pass.
     try:
         app = wx.GetApp()
         if app is not None:
             assert wx.Thread_IsMain()
 
             # The import of wx on Linux sets the handler for signal.SIGINT
             # to 0.  This is a bug in wx or gtk.  We fix by just setting it
             # back to the Python default.
             if not callable(signal.getsignal(signal.SIGINT)):
                 signal.signal(signal.SIGINT, signal.default_int_handler)
 
             evtloop = wx.EventLoop()
             ea = wx.EventLoopActivator(evtloop)
             t = clock()
             while not stdin_ready():
                 while evtloop.Pending():
                     t = clock()
                     evtloop.Dispatch()
                 app.ProcessIdle()
                 # We need to sleep at this point to keep the idle CPU load
                 # low.  However, if sleep to long, GUI response is poor.  As
                 # a compromise, we watch how often GUI events are being processed
                 # and switch between a short and long sleep time.  Here are some
                 # stats useful in helping to tune this.
                 # time    CPU load
                 # 0.001   13%
                 # 0.005   3%
                 # 0.01    1.5%
                 # 0.05    0.5%
                 used_time = clock() - t
-                if used_time > 5*60.0:
-                    # print 'Sleep for 5 s'  # dbg
-                    time.sleep(5.0)
-                elif used_time > 10.0:
+                if used_time > 10.0:
                     # print 'Sleep for 1 s'  # dbg
                     time.sleep(1.0)
                 elif used_time > 0.1:
                     # Few GUI events coming in, so we can sleep longer
                     # print 'Sleep for 0.05 s'  # dbg
                     time.sleep(0.05)
                 else:
                     # Many GUI events coming in, so sleep only very little
                     time.sleep(0.001)
             del ea
     except KeyboardInterrupt:
         pass
     return 0
 
 if sys.platform == 'darwin':
     # On OSX, evtloop.Pending() always returns True, regardless of there being
     # any events pending. As such we can't use implementations 1 or 3 of the
     # inputhook as those depend on a pending/dispatch loop.
     inputhook_wx = inputhook_wx2
 else:
     # This is our default implementation
     inputhook_wx = inputhook_wx3