An Actor-Based Framework for Real-Time Coordination

Programming language research should be driven by the needs of specific application domains, such as real-time embedded systems, multimedia, distributed data-base management applications, etc. For instance, most often large real-time applications involve distributed and concurrently but asynchronously operating devices. The correctness of the integrated systems depends not only on the correct operation of each individual device, but also on the correct cooperation among these devices. Furthermore, the correctness of device operation and cooperation requires that both the underlying logical computation be correct and the computation satisfy some notation of quantitative timing requirements. This thesis is a case study for how a language should be designed to suit a specific application domain. More specifically, I have designed RTsynchronizers, a high-level programming language abstraction for specifying real-time coordination constraints between objects in a distributed open system. RTsynchronizers enforce timing constraints on a group of computational objects. They are defined in terms of the interface of members in the group; thus they are independent of the representations of computational objects. During program execution, RTsynchronizers affect the scheduling of distributed objects to enforce real-time relations between events. With RTsynchronizers, we achieve the ability to separately specify and program functional components and the coordination constraints among these components, and the ability to reuse the computational code as well as coordination constraint code. This research uses theoretical and experimental methods. Specifically, the operational semantics based on RTsynchronizers and regular computational objects (modeled as actors) is defined. RTsynchronizers are implemented as C++ objects which are used by system schedulers in deciding the appropriate messages to be invoked at message destination computational objects. The implementation demonstrates the feasibility of making the existence of RTsynchronizers transparent to computational objects. Furthermore, an algorithm for detecting infeasible real-time coordination constraints at source code level is developed.