Why would blocking=False be slower?

[trajano]

I have this blocking code which works well already, but I was curious about the non-blocking mode

scrolling_up = False

def scroll_up():
    global scrolling_up
    scrolling_up = True
    while scrolling_up:
        ahk.send_input("{Blind}{WheelUp}")
        if ahk.key_state("LCtrl"):
            time.sleep(0.300)
        else:
            time.sleep(0.010)

So I tried to convert it to non-blocking to see what happens

def scroll_up():
    global scrolling_up
    scrolling_up = True
    while scrolling_up:
        result = ahk.send_input("{Blind}{WheelUp}", blocking=False)
        if ahk.key_state("LCtrl"):
            time.sleep(0.300)
        else:
            time.sleep(0.010)
        result.result()

But it seems the speed is significantly slower.

Am I doing something I am not supposed to do?

[spyoungtech]

When you use blocking=False, a new AutoHotkey subprocess is spawned to facilitate this. It takes some time for Windows to start the process as well as for the AutoHotkey interpreter to start and run the script. In tight loops, this can account for a significant slowdown.

In fact, before the daemon mode was implemented in #111 (and later became the default in version 1.x), all function calls invoked a new AutoHotkey process! In PR #111 I also noted the significant performance difference in these operating models:

normal_ahk()  # created a new process for every command
# 50 commands completed in 5.151455640792847
asyncio.run(daemon_mode()) # runs all commands in the same process
# 50 commands completed in # 0.17191839218139648

Something like a 25x difference! And since then we've also made significant performance improvements (700%+ in some cases!) in the daemon since then, so the daemon is even faster now.

So, for performance sake alone, you're usually better off not using blocking=False. Exceptions to this may be if you want to run multiple computationally expensive calls at once (like, say, finding multiple images simultaneously with image_search).

Using blocking=False is mostly useful when you want to run other Python code immediately, rather than blocking until AHK responds. The interfaces are also thread-safe, so you can call the same ahk instance/process from multiple threads... however, all calls still run sequentially (AutoHotkey itself is single-threaded so 1 process can only do 1 thing at a time anyhow). Using blocking=False you have true parallelism.