Scheduling precedence-constrained tasks in a distributed real-time system is an NP-hard problem. As a result, the task allocation and scheduling algorithms that use these heuristics do not scale when applied to large distributed systems. In this paper, we propose a novel approach that eliminates inter-task dependencies using shared buffers between dependent tasks. The system correctness, with respect to data-dependency, is ensured by having each dependent task poll the shared buffers at a fixed rate. Tasks can, therefore, be allocated and scheduled independently of their predecessors. To meet the timing constraints of the original dependent-task system, we have developed a method to iteratively derive the polling rates based on endto-end deadline constraints. The overheads associated with the shared buffers and the polling mechanism are minimized by clustering tasks according to their communication and timing constraints. Our simulation results with the task allocation based on a simple first-fit bin packing algorithm showed that the proposed approach scales almost linearly with the system size, and clustering tasks greatly reduces the polling overhead. 1

In this paper we experimentally evaluate the performance of a parametrized branch-and-bound (B&B) algorithm for scheduling real-time tasks on a multiprocessor system. The objective of the B&B algorithm is to minimize the maximum task lateness in the system. We show that a last-in-first-out (LIFO) vertex selection rule clearly outperforms the commonly used least-lower-bound (LLB) rule for the scheduling problem. We also present a new adaptive lower-bound cost function that greatly improves the performance of the B&B algorithm when parallelism in the application cannot be fully exploited on the multiprocessor architecture. Finally, we evaluate a set of heuristic strategies, one of which generates near-optimal results with performance guarantees and another of which generates approximate results without performance guarantees. 1 Introduction Since its introduction in the field of artificial intelligence, the branch-and-bound (B&B) strategy has been successfully used for finding optimal ...

Automatic tool support for scheduling applications on multiprocessor platforms is of paramount importance both to guarantee critical application demands and to keep development costs down. In this paper, we present GAST, an objectoriented evaluation environment for multiprocessor assignment and scheduling techniques. GAST is based on a decomposition approach where existing assignment and scheduling techniques have been broken down into a set of common operations. By combining these operations into a complete scheduling process, GAST offers a powerful toolbox of existing assignment and scheduling techniques. GAST has been implemented on several popular operating systems and is accompanied by a graphic visualization tool that allows for flexible interaction with the application scheduling process. 1 Introduction For economical reasons, single-processor computers have traditionally been the only viable option for many computer system designers. This has, in turn, limited the sphere of f...

The state-of-art approaches to embedded real-time software development are very costly. The high development cost can be reduced significantly by using model-based integration of reusable components (models and/or software modules). To this end, we propose an architecture that supports integration of software components and their behaviors, and reconfiguration of component behavior at executable-code-level. In this architecture, components are designed and used as building blocks for integration, each of which is modeled with event-based external interfaces, a control logic driver, and service protocols. The behavior of each component is specified as a Finite State Machine (FSM), and the integrated behavior is modeled as a Nested Finite State Machine (NFSM). These behavior specifications can be packed into a Control Plan program, and loaded to a runtime system for execution or to a verification tool for analysis. With this architecture, embedded software can be constructed by selecting an...

The design and construction of Embedded SoftWare (ESW) has become critically important to the development...

Software Performance Engineering (SPE) is a systematic approach that uses performance models to assess requirements, design and hardware alternatives, starting early in the life-cycle while a wide range of options exists, and continuing through the life-cycle. Despite documented successes of SPE it still faces technical barriers that hinder its widespread use. The first barrier is, that modeling often has a prohibitive cost in time and effort. The second barrier is, that analyzing model results to diagnose problems and recommend design alternatives for performance improvement is not an easy task, as it requires special expertise. The research proposed here is intended to attack both of these difficulties. It proposes a practical performance engineering framework that provides designers with automated performance assistance for high-level software design. The framework provides assistance to designers by: (1) facilitating the process of building and evaluating performance models, and (...

We present a SAT-based approach to the task and message allocation problem of distributed real-time systems. In contrast to the heuristic approaches usually applied to this problem, our approach is guaranteed to find an optimal allocation for realistic task systems running on complex target architectures. Our method is based on the transformation of such scheduling problems into nonlinear integer optimization problems. The core of the numerical optimization procedure we use to discharge those problems is a solver for arbitrary Boolean combinations of integer constraints. Optimal solutions are obtained by imposing a binary search scheme on top of that solver. Experiments show the applicability of our approach to industrial-size task systems. 1

Abstract—Constructing runtime tasks, or operating system-level processes/threads, from the components of software design models is crucial to the model-based development of embedded control software. A better method should explore more design choices and reduce the overheads of the runtime system to meet the timing and resource constraints of embedded control software. This paper presents a novel, two-step method for systematic and automatic construction of runtime tasks from software design models. It uses graph transformation to construct a task set meeting system-level end-to-end (e2e) timing constraints. Its first step decomposes the system-level e2e timing constraints into the components ’ timing constraints, which form a necessary condition for any valid and feasible schedule. The second step iteratively merges the components into tasks and sequences their executions. A thus-constructed task set is proven to meet both intercomponent precedence and system-level e2e timing constraints and to minimize runtime overheads by minimizing the total number of resultant tasks. Our evaluation results based on randomly generated software models have shown that the proposed method outperforms commonly used methods and is also scalable. Index Terms—Task construction, model transformation, model-based design, embedded software. 1

Abstract—Real-time transactions are often used to model distributed applications in many fields such as multimedia, automotive, etc. Transactions are sequences of real-time tasks activated periodically. All tasks of a real-time transaction must complete before an end-to-end deadline set by the designer. The holistic analysis of a set of transactions does not provide any degree of isolation among the transactions, preventing a true compositional analysis of real-time transactions. In this paper, we propose to treat each transaction as a separate component. We investigate the deadline assignment that minimizes the resource requirement of a single transaction by presenting both theoretical and experimental results. I.

As distributed real-time applications gain in popularity, a key challenge is to allocate resources so that diverse realtime requirements (including non-real-time applications), distributed application components and varying workloads can all be accommodated without violating timeliness constraints. We examine the problem of resource allocation in distributed soft real-time systems, where both network and CPU resources are consumed. The timeliness constraints of applications are expressed through utility functions, which compute “benefit ” as a function of end-to-end latency. We present LLA (Lagrangian Latency Assignment), a scalable and efficient distributed algorithm which maximizes aggregate utility by computing an optimal trade-off between end-to-end latency and allocated resources. The algorithm runs continuously and adapts to both workload and resource variations. LLA is guaranteed to converge if the workload and resource requirements stabilize. We evaluate the quality of results and convergence characteristics under various workloads, using both simulation and realworld experimentation. 1.