I think nowadays we could actually switch to a fully event/timer driven
main loop for Morphic without major drawbacks. This was not true when
Morphic was designed, since the VM back then was not event-based.

Instead of a fixed interCyclePause we simply need to wait on a semaphore
that should get signaled when a new event is available, and timed-out when
the next Morphic alarm / step message is due. It probably also needs to be
triggered when a deferred UI message is added.

On the VM side, we would need to replace relinquishProcessorForMicroseconds
with something like goToSleep. This primitive would block the VM completely
until the ActiveDelay expires or some other event occurred (input, file
becomes readable, socket data available etc).

The advantage of this would be, as Holger wrote, that we would become a lot
more battery-efficient, since we would wake up only if there is actual work
to do.

- Bert -

On Wed, Aug 30, 2017 at 7:56 AM, Marcel Taeumel <marcel.taeumel at hpi.de>
wrote:

>
> Hi Holger,
>
> The Morphic main loop empties the event queue (mouse & keyboard) in each
> cycle. It also checks for drawing requests and stepping. If that processing
> goes too fast, it tries to free CPU time via a delay (so that the idle
> process can run if no other).
>
> No, it does not make sense to get rid of that pause/delay/tick. ;-) The
> system is NOT event-based at that lower level. It is just polling/looping.
> A single UI process, which sleeps occasionally. By design.
>
> Note that if you want to run that in the cloud, just avoid busy morphs and
> Morphic should use very little CPU resources.
>
> Best,
> Marcel
>
> Am 29.08.2017 23:29:21 schrieb Holger Freyther <holger at freyther.de>:
>
> Hi,
>
> I have done some early prototype for the Unix VM end of 2015(?) and I have
> improved and repeated these for MacOS now and the thread based heartbeat
> (now that it is the universal default). I won't make it to ESUG this year
> but this might be something to play with?
>
> The motivations is simple: Polling increases the CPU usage which will
> reduce your battery life, takes away resources from other processes (e.g.
> more Pharo images) or these days increases your cloud computing bill. On
> top of that it might increase network latency (time from socket becoming
> readable to the time the semaphore is signaled).
>
> To complete the work we have work inside the Image and the VM and some of
> it is on the way and others might need more discussion.
>
>
> The idle process:
>
> ProcessorScheduler>># idleProcess
> "A default background process which is invisible."
>
> [true] whileTrue:
> [self relinquishProcessorForMicroseconds: 1000]
>
> Let's please yield the CPU for more than a 1ms. Unless I am missing
> something an expired Delay or network IO would make us wake up earlier
> anyway?
>
>
> The delay scheduler:
>
> The VM supports that when the next wake-up time is set to 0, the VM can
> sleep indefinitely. There is a pending patch to sleep "0" in our Delay
> scheduler. Currently we force a wake-up earlier than that. I think we
> should trust the VM to do wake us up even if it is a second away.
>
>
> Morphic UI:
>
> I don't understand the WorldState>>#interCyclePause but then I never
> looked at Morphic. Do we really need to poll like that? Under which
> circumstances does the world update? We get an event (where we have the
> event semaphore), we get some I/O (where we have a semaphore) or we have a
> timeout (where we sleep on a semaphore). Did anyone ever look at removing
> the tick?
>
>
> VM I/O:
>
> Currently we receive a SIGIO but from what I can see (and I still need to
> write a benchmark) the processing might be delayed 20ms? My hack removes
> the usage of nextPollUsecs and instead checks a variable that is set by the
> SIGIO handler. Besides missing memory barriers this should work(tm).
>
> The biggest issue seems that for macos/ios the input is driven by polling.
> E.g. some wheel events seem to require to pump the event queue. Is this
> something we could trigger from the image in the future? I had hoped to get
> a fd to a machport we could get SIGIO for.. but that doesn't seem to exist.
> I have hacked out the honoring of the relinquish delay, added the polling
> into a iOS specific routine and thanks to the Morphic Delay we bump the
> event loop frequently enough.
>
>
> VM heartbeat thread:
>
> The process keeps ticking even if the VM doesn't run. E.g. sleeps and
> waits for an event. There is a cost in deciding when to halt the thread so
> there must be a cut-off for which delays we bother to disable the heartbeat
> thread. I think the current code would allow the hearbeat to drift so the
> new code might just make it a bit worse.
>
>
> Where are we now?
>
> I have pushed my changes to https://github.com/zecke/
> opensmalltalk-vm/tree/mac-use-less-cpu and would be happy to have people
> look at it, look at the memory synchronization, maybe run to see if they
> notice extra delays or such?
>
>
> I started the same image with the plain-vm and my hacked one and let it
> run for about 20min. The output is coming from top.
>
> COMMAND %CPU TIME
> Pharo 4.3 00:48.49
> Pharo 0.8 00:10.20
>
>
> Looking for comments and feedback.
>
> regards
> holger
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.squeakfoundation.org/pipermail/squeak-dev/attachments/20170830/939634e8/attachment.html>