The project itself is a prototype implementation of ASAP as given in wd-asap-spec-01d.doc found at the source forge project site under references for the easyasap package. Sketch 5.2.2, for example, is a tar file containing the source code and example logs. For the sake of this topic, the concurrency directory holds files of interest here. My motivation is that I wanted to be able to "address" threads of execution by a URI, so I have "named" threads and channels. In the implementation SOAP "dispatcher" thread gets messages, deserializes them into "Request" objects and puts them on to a named channel consumed by a thread with the same name. Actually, in reality, there is the factory service, service instance and task level of execution, but that's the idea. Here's a brief description of include/concurrency: Ted Yuan's ProducerConsumer.h provides a producer and consumer pattern he describes in the C/C++ Users Journal, January 2004, p28-31. Consumers are sort of like the ACE Task active objects. The descendants need to implement the consume(T) function to handle objects taken from the channel, and may implement cancel() to determine whether or not to exit early (or in my case, to do work outside of strictly serving the channel, like timing out on an outer state machine) I've modified the code so that the consumer uses a timed wait if a timeout is provided. Things I'm not thrilled with are the way things need to be constructed with references and I think the source file should be broken up to include individual files for the template classes. NamedThreads descends from boost::thread_group and maps names to thread pointers. ThreadCommunicationManager_t is a template class that by default inherits from NamedThreads and further provides a map containing pointers to channels, registration and removal operations, and operations for putting an object to a channel, registering and starting a consumer if necessary. ManagedConsumer_t is a template class for consumers that contains a weak pointer to its thread manager and wraps access to consumer members. ManagedConsumerPrototyper_t is a template class that contains a weak pointer to its thread manager, wraps putting and joining operations and provides an ancestor for classes that create managed consumers. The idea originally was to support a prototyping factory pattern, but this was sort of foiled by the way Consumers reference their channels. I've found a lot of trouble could have been avoided if Consumers didn't reference channels the way they do. makeManagedConsumer_t is a template function for creating a managed consumer prototype, it creates the channel, latch, and consumer superclass. In the example directory, tcm_demo.cc shows how ThreadCommunicationManager_t and makeManagedConsumer_t can be used. I'm sure it could be cleaned up and improved, but thought I should offer it. On Feb 18, 2004, at 1:11 AM, Vladimir Prus wrote:
John Fuller wrote:
A recent project of mine uses shared queues based on Ted Yuan's producer-consumer code. The producer consumer code has been modified to use timed waits, and in my concurrency directory I provide management for named threads and channels.
If would help if you send a pointer to docs or home page describing something. As it stands, I could find only large archive containing lots of files. It's hard to understand anything.
- Volodya
_______________________________________________ Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost