A pattern language for efficient, predictable, scalable, and flexible dispatching mechanisms for distributed object computing middleware

In many application domains, the distributed object computing (DOC) middleware is responsible for dispatching upcalls to one or more application objects when events or requests arrive from clients. Implementing efficient, predictable, and scalable middleware dispatching mechanisms is hard and implementing them for multi-threaded systems is even harder. In particular dispatching mechanisms must be prepared to dispatch upcalls to multiple objects, to handle recursive requests originated from application-provided upcalls, and must often collaborate with the application to control object life-cycle. In our DOC middleware research we have implemented many dispatching mechanisms that repeatedly apply common solutions to solve the challenges outlined above. Moreover, we have discovered that the forces constraining dispatching mechanisms often differ slightly thereby requiring alternative solutions. This paper presents two contributions to the design and implementation of efficient, predictable, scalable and flexible DOC middleware and applications. First, it shows how patterns can be applied to the object-oriented systems to capture key design and performance characteristics of proven dispatching mechanisms. Second it presents a pattern language that describes successful solutions that are appropriate for key dispatching challenges that arise in various real-time DOC middleware and applications