Shangping Ren

RTsynchronizer: language support for real-time specifications in distributed systems

We argue that the specification of an objects functional behavior and the timing constraints imposed on it may be separated. Specifically, we describe RTsynchronizer, a high-level programming language construct for specifying real-time constraints between objects in a distributed concurrent system. During program execution, RTsynchronizers affect the scheduling of distributed objects to enforce real-time relations between events. Objects in our system are defined in terms of the actor model extended with timing assumptions. Separation of the functional behaviors of actors and the timing constraints on patterns of actor invocation provides at least three important advantages. First, it simplifies code development by separating design concerns. Second, multiple timing constraints can be independently specified and composed. And finally, a specification of timing constraints can be reused even if the representation of the functional behavior of actors has changed, and conversely.A number of examples are given to illustrate the use of RTsynchronizers. These examples illustrate how real-time constraints for periodic events, simultaneous events, exception handling, and producer-consumer may be specified.

On-Line Scheduling of Real-Time Services for Cloud Computing

In this paper, we introduce a novel utility accrual scheduling algorithm for real-time cloud computing services. The real-time tasks are scheduled non-preemptively with the objective to maximize the total utility. The most unique characteristic of our approach is that, different from the traditional utility accrual approach that works under one single time utility function (TUF), we have two different TUFs--a profit TUF and a penalty TUF--associated with each task at the same time, to model the real-time applications for cloud computing that need not only to reward the early completions but also to penalize the abortions or deadline misses of real-time tasks. Our experimental results show that our proposed algorithm can significantly outperform the traditional scheduling algorithms such as the Earliest Deadline First (EDF), the traditional utility accrual scheduling algorithm and an early scheduling approach based on the similar model.

A concept lattice-based event model for Cyber-Physical Systems

Cyber-Physical Systems (CPS) involve communication, computation, sensing, and actuating through heterogeneous and widely distributed physical devices and computational components. The close interactions of these systems with the physical world places events as the major building blocks for the realization of CPS. More specifically, the system components and design principles should be revisited with a strictly event-based approach. In this paper, a concept lattice-based event model for CPS is introduced. Under this model, a CPS event is uniformly represented by three components: event type, its internal attributes, and its external attributes. The internal and external attributes together characterize the type, spatiotemporal properties of the event as well as the components that observe it. A set of event composition rules are defined where the CPS event composition is based on a CPS concept lattice. The resulting event model can be used both as an offline analysis tool as well as a run-time implementation model due to its distributed nature. A real-life smart home example is used to illustrate the proposed event model. To this end, a CPS event simulator is implemented to evaluate the developed event model and compare with the existing Java implementation of the smart home application. The comparison result shows that the event model provides several advantages in terms of flexibility, QoS support, and complexity. The proposed event model lay the foundations of event-based system design in CPS.

Actors, roles and coordinators — a coordination model for open distributed and embedded systems

This paper presents a coordination model, the Actor, Role and Coordinator (ARC) model, to address three main concerns inherent in a pervasive Open Distributed and Embedded (ODE) system: dynamicity, scalability, and stringent QoS requirements. The model treats a pervasive ODE system as a composition of concurrent computation and coerced coordination. In particular, concurrent computation is modeled as Actors, while coerced coordination specifies the systems QoS requirements by mapping them to coordination constraints. The coordination constraints are transparently imposed on actors through message manipulations, which are carried out by the roles and coordinators. The coordinators are responsible for the coordination among roles, while the roles in our model provide abstractions for coordinated behaviors that may be shared by multiple actors and further assume local coordination responsibilities for the actors playing the roles. The roles behavior abstraction decouples the syntactic dependencies between the coordinators and the actors, thus shielding the coordinator layer from the dynamicity of underlying actors inherent in ODE systems. This paper also formally defines the role and coordinator behaviors and the composition of the actor computation model with the proposed coerced coordination model. Our formal study has shown that the ARC system is closed under composition and recursion.

A Modular Approach to Programming Distributed Real-Time Systems

Conventional real-time programs associate real-time requirements with individual commands in a program. This approach has three weaknesses. First, it intermixes two different design concerns: functional correctness and temporal correctness. Second, by mixing real-time requirements with program statements it makes it harder, and in some cases infeasible, to specify constraints between objects. Third, it limits the ability to independently modify either the timing constraints or the representations of objects. We describe a new approach that separates real-time constraints from functional aspects of an application; real-time constraints are described by synchronization code between the interfaces of objects. Objects in our system are defined using a real-time variant of the Actor model. We define a high-level programming language construct calledRTsynchronizer, which specifies a collection of temporal constraints between actors. Thus, our approach separates what an object does from when it does it. Such separation also facilitates the ability to dynamically modify real-time constraints. We illustrate the use of RTsynchronizers by a number of examples and then describe a meta-architecture that can be used to implement RTsynchronizers.

Profit and penalty aware (PP-aware) scheduling for tasks with variable task execution time

As computing devices and the Internet technology advances, real-time on-line services are emerging. Different from traditional real-time applications for which the scheduling objective is to meet task deadlines, the optimization goal for on-line service systems is to maximize profit obtained through providing timely services. For this class of applications, there are two distinctive characteristics: (1) tasks, i.e., client requests, are associated with a pair of unimodal time functions, representing system accrued profit when a task is completed before its deadline, or accrued penalty if otherwise; and (2) requests execution times vary in a wide range. The paper presents a new scheduling algorithm, i.e., the Profit and Penalty aware (PP-aware) scheduling algorithm, with an objective to maximize systems total accrued profit. Our simulation results have empirically shown the advantages, in respect of system total accrued profit, of the proposed algorithm over other commonly used scheduling algorithms, such as Earliest Deadline First (EDF) and Utility Accrual (UA) algorithms.

Profit and Penalty Aware Scheduling for Real-Time Online Services

As computer and Internet technology continue to advance, real-time online services are emerging. Different from traditional real-time applications for which the scheduling objective is to meet task deadlines, the optimization goal for online service systems is to maximize profit obtained through providing timely services. For this class of applications, there are two distinctive characteristics. First, tasks are associated with a pair of time dependent functions representing accrued profit when completed before their deadlines and accrued penalty otherwise, respectively. Second, the service requests or tasks arrive aperiodically with execution time varying in a wide range. This paper presents a novel scheduling method and related analysis for such applications. Two scheduling algorithms, i.e., the nonpreemptive and preemptive Profit and Penalty aware (PP-aware) scheduling algorithms, are proposed with an objective to maximize systems total accrued profit. Our simulation results clearly demonstrate the advantages of the proposed algorithms, with respect to the system total accrued profit, over other commonly used scheduling algorithms, such as Earliest Deadline First (EDF) and Utility Accrual (UA) algorithms.

Comparing three coordination models: Reo, ARC, and PBRD

Three models of coordination-Reo, Actors-Roles-Coordinators (ARC), and Policy-based Russian Dolls (PBRD)-are compared and contrasted according to a set of coordination features. Mappings between their semantic models are defined. Use of the models is illustrated by a small case study.

Performance Comparisons of Parallel Power Flow Solvers on GPU System

This paper transforms sequential power flow problem to a parallel problem and solves it on GPU. In particular, we implement parallel Gauss-Seidel solver, Newton-Raphson solver, and P-Q decoupled solver using CUDA (Compute Unified Device Architecture) on GPU. The aim is to investigate the performance of the three different parallel power flow solvers. We use four IEEE standard power systems and one actual running power system from Shang dong Province as the test cases when comparing the speedups that a GPU system can provide. The results show that Newton-Raphson solver has the best speedup when it is operated on GPU, Gauss-Seidel solver performs the worst, and P-Q decoupled solver is in the middle. The test results also indicate that when the size of the system is small, GPU does not seem to have advantages over CPU from computation time perspective. However, as the size of the system increases, the advantages of GPU becomes more clear. For instance, when the system has close to one thousand bus counts, the GPU can provide as high as over fifty-three times speedup.

Specification of real-time interaction constraints

We present a coordination language and its semantics for specification and implementation of object-oriented real-time systems. Real-time systems operate under real-time constraints, and our language supports expression thereof. In our language, a system is modeled by two separate but complementary descriptions: A collection of objects define the systems structure and functional behavior and a set of interaction constraints define how these objects may interact. Our language thereby supports development of real-time systems by enabling objects build in isolation or re-used from other systems to be composed via interaction constraints. We use the Actor model to describe objects and the concept of real-time synchronizers to describe interaction constraints. Our model is accompanied by a formal semantics that precisely defines what real-time constraints means, and what constitutes a programs correct real-time behaviors. The semantics defines how the system may evolve in the real-time domain, and what progress guarantees the language makes. We briefly discuss implementation problems and potential solutions.