Andrew Dunstan wrote:
> If you have an alternative suggestion them you need to make it now.
>
well, I'm not sure about the non-collapsing business but no matter.
> We are not intending to use FDs for message passing. They will be
> stored in shared memory. See previous discussions for details:
>
I'm more interested in replacing the pgkill wakeup mechanism with
something that is less sucky on Win32.
If you just want to send a wakeup then making a pipe RPC is crazy since
it introduces a lot of scheduling.
A unix domain datagram socket to which processes can send one byte is
enough to toggle the readability
if the socket without doing much transfer, and using an atomic flag in
shm means that subsequent
wakeups can be elided until the process acknowledges the signal, which
it should do before scanning the
shm queue.
I don't see any reason to pass the data through the kernel if you have
the shm handling routines,
particularly if you have ones that handle spilling.
If you're happy with using signals on UNIX (and Tom suggested that
SIGUSR usage and signal handling
might be one of the concerns about allowing threaded addins) then at
least on Win32 it should be worth
adding a variant of kill which has a void return and does not try to
return information about the validity
of the target process id.
Personally I try to avoid signals and would prefer an fd level-based
signal. But YMMV.
I was just wondering if what you're doing could be generalised as a
'post to backend' system that can be
used for other duties in future, so you'd need a message type and
payload blob rather than assuming
that the type is 'notify' and the payload is the payload length.
If you had a pgsql extension that was 'wait for notificiation' or 'wait
for row in message table' then
the wakeup could essentially be directed at code in the target backend,
rather than using it as a conduit to
target code in the client.
James
