Trailing throttle syncs to front-end

[pankgeorg]

I'm using a slightly modified version of Flux.jl's throttle: https://github.com/FluxML/Flux.jl/blob/8afedcd6723112ff611555e350a8c84f4e1ad686/src/utils.jl#L662

[pankgeorg]

Converting this to draft as I would like to check whether we can add a lock to the function call; I don't trust concurrency 🎈✨⭐

[pankgeorg]

Added 'thread safety', which means that the function cannot be running by two threads simultaneously.
The caveat is that (in tightly called sequences) the timeout time gets extended by the time the function is running.

The last thing to consider is, do mutations that may happen 'simultaneously' matter? should every throttled function call get its own copy of the state??

[fonsp]

In the first paragraph of your comment, aren't you saying that the second paragraph is not possible?

[fonsp]

Can you add some basic tests with sleep to make sure that the basic throttling is working? The code got a bit too complicated to just review it. E.g.

x = Ref(0)

function f()
	x[] += 1
end
f()
@test x[] == 1

dt = 1/100
ft, stop = throttled(f, dt; initial_cooldown=true)

for x in 1:10
	ft()
end
@test x[] == 1
sleep(2dt)
@test x[] == 2

for x in 1:10
	ft()
end
@test x[] == 3
sleep(2dt)
@test x[] == 4


for x in 1:5
	ft()
	sleep(1.5dt)
end
@test x[] == 9
sleep(2dt)
@test x[] == 9

###

ft()
ft()
@test x[] == 10
stop()
@test x[] == 11
sleep(2dt)
@test x[] == 11

[pankgeorg]

In the first paragraph of your comment, aren't you saying that the second paragraph is not possible?

Not exactly - I'm saying that if f is throttled by the function, and has argument1, argument2 as arguments, then, f will never run when f runs. (first paragraph)

BUT if g is mutating argument1, argument2 there is no guarantee that f and g don't run such as they corrupt each other's data. (second paragraph)

I'm not even sure if that's possible by Julia's thread model (since our f doesn't yield, but it may do some network stuff that counts as 'idle'??)

The thing is that we'll probably need to be locking the resource (argument1, argument2 = session, notebook).

Can you add some basic tests with sleep to make sure that the basic throttling is working? The code got a bit too complicated to just review it. E.g.

Of course! I have a notebook that does this here: https://github.com/pankgeorg/spam/blob/main/throttled.jl, I'll convert to a test

[fonsp]

Why does f take arguments? It makes more sense to drop that feature

[pankgeorg]

This code will run at most once per 1/20 sec, @async.
BUT there is no guarantee I can think of that code that mutates (notebook, session) will not run right before/right after/inbetween.

e.g. runsingle! at line 80-something

[pankgeorg]

Why does f take arguments? It makes more sense to drop that feature

The feature is not related; the () -> send_notebook_changes!(ClientRequest(session=session, notebook=notebook)) holds references to session and notebook.

locking the resource (argument1, argument2 = session, notebook).

We already lock notebook, right?

Pluto.jl/src/evaluation/Run.jl

Line 10 in 7005c6b

take!(notebook.executetoken)

all these functions all hold the lock, I think.

[fonsp]

The feature is not related

I see, I can try to think about the thread safe stuff tomorrow with a CLEAR brain :) It does seem like the code would be simpler if you deleted the args, kwargs, and result features. Because then, later could just be a boolean, for example.