self.call() is executed on next tick() (not immediately) about circuits

[spaceone]

Maybe we could implement a method self.fastcall() ?

[prologic]

👍 Worth looking in to :)

I suspect it might have something to do with the fact that coroutines are handled in the "next tick" so to speak; whereas fired events are "queued up" for immediately handling.

But maybe we can improve this?

[prologic]

With a much simpler implementation of this "slow test":

from circuits import Component, Event


class counter(Event):
    """counter Event"""

    complete = True


class Slow(Component):

    def started(self, *args):
        #  self.fire(counter(10))
        yield self.call(counter(10))

    def counter(self, n):
        for i in xrange(n):
            print i
            yield i

    def counter_complete(self, *args):
        raise SystemExit(0)

Slow().run()

I only see a ~10% performance drop in using self.call() which IHMO is acceptable seeing what it's doing and all :) Thoughts?

[spaceone]

That code does not what my code does. You are call()-ing 1 time not 10/30 times (which is a valid use case). Where then 10% is very much. At least it must be documented, also using call() is useless then if it is in the endeffect slower than just fire()ing.

[prologic]

Hmm I'll have to study your contrived example a bit more :) I'm not quite following it yet :)

[spaceone]

Real life code is always better: spaceone/circuits.http@ef5d7f6

[prologic]

Yeah okay I see :) I'll have to play with this some more and see what's going on. To be honest I'm not sure why you're using coroutines (or were trying to) there anyway?

[spaceone]

Well, I thought call is not just equivalent to yield self.wait(self.fire(event).event). I thought it would just call the event handlers synchroniously. Now I looked at the code and I am smarter ;)

[prologic]

Ahh so in your particular case you were calling the wrong API method? yield self.wait() is indeed NOT equivalent to self.call() :) Both in effect create coroutines!

[spaceone]

What are the exact differences between call() and wait()? In my particular case I want to call the handlers as soon as possible. I probably misunderstood how call() is meant to be used?

[prologic]

Yeah so call/wait are essentially the same. .call() does a .fire() and .wait(), whilst .wait() only wiats for an event's completion. Both are used to write synchronous code that is otherwise asynchronous underneath, both turn the event handler into a coroutine (_because you _have* to yield*).

[prologic]

Any further thoughts/comments on this? Do we need to change/fix/update anything here? Improve the documentation around this perhaps?

[prologic]

@spaceone Do you have any thoughts on improving this at all -- Or should we just document it better? call/wait provide coroutines (cooperative threading); I would never expect them to be as performant as "fire and forget". I have however observed the same behaviour as what you've described in that using coroutiens does cost a bit of performance for the sake of "synchronization".

[prologic]

Maybe we could implement a method self.fastcall() ?

I'm not sure; but it would be backwards compatible at least. New API.

[spaceone]

Maybe fixing #136 via #213 already solves this problem - at least it gets improoved