Hi,
I look into a way to implement something like Erlang's selective process by
having Delay
or something like it wait on multiple Semaphores (and maybe blocks in the
future but that
leads the question of side-effects if the event is not used) and fire on the
first one ready
without having to deal with many Processes.
The usecases I have in mind right now are:
* Wait for a delivery time or if any new work has come up
* When connecting a call (e.g. two SIP calls) I want to manage the
state from a
central place (e.g. like an event inbox) and dispatch events from the
same context
and I do not know which side the event occurs.
SelectiveReceive new
check: database readableSemaphore do: [ev := self nextDatabaseEvent];
check: file readableSemaphore do: [];
timeoutDo: [];
runFor: 30 seconds.
A prototype to get a feel for the API could be built by spawning n-processes
that each
wait on their own semaphore for the timeout and then create another semaphore
that
is signalled by these processes in case of a wakeup signal the new Semaphore
and then
in the runFor: selector kill all remaining processes..
What do you think of this pattern instead of having to deal with concurrency
with more
locking, more fine grained locking? What would it take to get this deeper into
Pharo? I
think fundamentally a Process would need to be able to sleep on a list of
semaphores?
Is that feasible?
kind regards
holger
