Throttling and blocking in cap/message-passing systems?

This might be slightly off-topic, but given the large overlap between 
message passing based architectures and capability based systems, I 
thought it would still be of interests to some on the list.

I am currently working on a computer-forensics related subject where I'm 
looking into (unfortunately non-cap-based) message passing 
architectures. As the base architecture is
basically fully asynchronous (practically) infinite buffer message 
passing, the concept of blocking operations is basically foreign to the 
existing system. There are however performance issues related to the 
fully asynchronous (practically) infinite buffer message passing setup 
(related to disk cache misses) that would make the introduction of 
blocking/throttling a potentially interesting addition from a 
performance point of view.

The idea would be that the messaging subsystem would keep track of disk 
cache statistics and throttle the normally asynchronous message passing 
by temporary making send operations block.

I have a few questions that i hope someone on this list could help me 
finding an answer to:

1) Is anyone aware of papers that may be relevant to the design of such 
a system, whether just message passing architecture related or specific 
to capability based  message passing architectures. Also papers showing 
that this would be essentially a bad idea are very welcome at this 
point.
2) Is anyone aware of a (preferably capability-based) implementation 
that might be suitable as message passing underpinning for such a 
disk-cache stats driven throttling/blocking message passing system?

T.I.A,

Rob