Which internals call os.pullEventRaw?

[Zirunis]

Okay, this is a little complex but I'm working on a project that has been on my mind for a long time now and I think is going to interest a few people. I don't want to let the cat out of the bag yet but it requires me to fiddle around with built-in globals. Essentially I found out that something is calling os.pullEventRaw() whenever I click in the terminal, even if a program is running. That my clicks would queue events is obvious to me but who catches them? Look at this simple test-script:

local pullEventRaw = os.pullEventRaw
os.pullEventRaw = function(sFilter)
    if sFilter == "turtle_inventory" then
        local result = pullEventRaw(sFilter)
        print("Expected")
        return result
    else
        local result = pullEventRaw(sFilter)
        print("Unexpected")
        return result
    end
end

os.pullEvent("turtle_inventory")
os.pullEventRaw = pullEventRaw

Any click or keypress prints Unexpected to the terminal, even though I'd expect nothing to happen until the turtles inventory changes. I understand that somewhere internally all events must be caught in order to look at the event type and check whether it is "turtle_inventory" to then resume my program. But I thought that would be on the Java side and not affected by me overwriting os.pullEventRaw.

[SquidDev]

The easiest thing here may be to add a print(debug.traceback()) call to your function, and see where these are coming from.

CraftOS doesn't run your program directly, but goes through several layers of coroutines, in order for things to run in parallel. Off the top of my head, you'll have:

• The bios calls parallel.waitForAny, whose loop will pull events.
• That runs rednet.run in parallel, which also pulls events.
• On advanced computers, multishell adds another layer of coroutines, and so another pullEventRaw.
• Finally, the shell runs each program in its own coroutine, so that's one more event pull.

[Zirunis]

Thank you, I'll try that!
Why I am mainly concerned about this is determinism. Given the program doesn't use randomness (so no math.random and no pairs()) the program flow should be exactly the same, right? Or could for example turtle.forward() calling sleep lead to non-determinism because of the timer essentially leading to a race condition of who catches it first? The outcome would obviously be the same but would the "code flow" (the sequence of lua instructions) be guaranteed to be the same? On the one hand I'm leaning towards yes because coroutines are deterministic, on the other hand towards no because of the mentioned timers. If you don't know, what would be your best guess?

[SquidDev]

When you've got events coming from an external source (such as turtle movement, timers, http requests), there's not any guarantee about what order events are pushed to the queue. For instance, os.startTimer(0); os.startTimer(0) might queue its timer events in either order.

However, once an event is received within CraftOS, the processing of it should be entirely deterministic.