Scheduling of Embedded Real-Time Systems: A Constraint Programming Approach

Transcription

1 THESIS FOR THE DEGREE OF LICENTIATE OF ENGINEERING Scheduling of Embedded Real-Time Systems: A Constraint Programming Approach CECILIA EKELIN Department of Computer Engineering CHALMERS UNIVERSITY OF TECHNOLOGY Göteborg, Sweden 2001

2 Scheduling of Embedded Real-Time Systems: A Constraint Programming Approach CECILIA EKELIN Technical Report no. 410L Department of Computer Engineering Chalmers University of Technology SE Göteborg, Sweden Phone: +46 (0) Contact information: Cecilia Ekelin Department of Computer Engineering Chalmers University of Technology Hörsalsvägen 11 SE Göteborg, Sweden Phone: +46 (0) Fax: +46 (0) cekelin@ce.chalmers.se URL: cekelin Printed in Sweden Chalmers Reproservice Göteborg, Sweden 2001

3 Scheduling of Embedded Real-Time Systems: A Constraint Programming Approach CECILIA EKELIN Department of Computer Engineering, Chalmers University of Technology Thesis for the degree of Licentiate of Engineering, a Swedish degree between M.Sc. and Ph.D. Abstract For embedded real-time systems, a correct timing behavior must be guaranteed as a result of the design. Therefore, an important part of the design process is the allocation and scheduling of software tasks onto the hardware architecture. However, the various application constraints typically found in embedded systems significantly complicates this task. Furthermore, to be costeffective, the design of an embedded system must often be optimal, in terms of objectives such as cost and performance. In this thesis I have studied how the constraint programming paradigm can be applied to the problem of optimal allocation and scheduling for embedded real-time systems. In particular, this work addresses two major problems that appear in the construction of allocation and scheduling algorithms for such systems. First, it must be possible to model the system accurately enough to allow the expression of real-world constraints. Second, the run-time performance of the allocation and scheduling algorithm must be reasonable for typical applications. This thesis demonstrates that constraint programming offers support for the development of a scheduling framework that provide the necessary features. Keywords: real-time systems, optimization, constraint programming, task allocation and scheduling, search heuristics, complex constraints, system modeling, complexity reduction i

4 ii

5 List of Appended Papers This thesis is a summary of the following four papers. References will be made to the papers using the Roman numerals assigned to each paper. I. Cecilia Ekelin and Jan Jonsson, Real-Time System Constraints: Where do They Come From and Where do They Go?, In Proceedings of the International Workshop on Real-Time Constraints, Alexandria, Virginia, USA, October 16, II. Cecilia Ekelin and Jan Jonsson, Solving Embedded System Scheduling Problems using Constraint Programming, Technical Report no , Department of Computer Engineering, Chalmers University of Technology, Sweden, Submitted for publication. III. Cecilia Ekelin and Jan Jonsson, A CLP Framework for Allocation and Scheduling in Embedded Real-Time Systems, Technical Report no , Department of Computer Engineering, Chalmers University of Technology, Sweden, Submitted for publication. IV. Cecilia Ekelin and Jan Jonsson, Evaluation of Search Heuristics for Embedded System Scheduling Problems, In Proceedings of the International Conference on Principles and Practice of Constraint Programming, Paphos, Cyprus, November 26 December 1, iii

6 iv

7 Contents 1 Introduction 1 2 Background EmbeddedReal-Time Systems Problem Space Possible Approaches PreviousWork ConstraintProgramming Research Issues 9 5 Summary of Papers 10 I Real-Time System Constraints: Where do They Come From and Where dotheygo? II Solving Embedded System Scheduling Problems using Constraint Programming III A CLP Framework for Allocation and Scheduling in Embedded Real- Time Systems IV Evaluation of Search Heuristics for Embedded System Scheduling Problems Discussion and Future Work 13 Acknowledgments 14 References 15 Appended Papers I II III IV v

8

9 1 Introduction Today, electronic systems are becoming increasingly popular as replacement for mechanical solutions in products such as automobiles and airplanes. Such systems are highly application-specific in nature and are frequently referred to as embedded because of their interaction with a well-defined environment. Embedded systems must often respond to stimuli from the environment within a certain time-limit. Failure in meeting these real-time demands may result in loss of lives or property. Therefore, for an embedded real-time system, a crucial part of the design is to ensure a correct timing behavior. The basic structure of an embedded system is a number of software tasks and a hardware architecture consisting of a network of nodes. In the design process it has to be decided on which node each task should execute (allocation) and also when each task should execute (scheduling), such that all design constraints are satisfied. When considering design objectives such as cost and dependability, some solutions to the allocation and scheduling problem may be regarded as better than others, making an optimization approach desirable. Unfortunately, this optimization process is far from trivial due to the inherent complexity of the problem. For example, the addressed optimization problem is in general NP-hard, resulting in an algorithm computational complexity that (most likely) grows exponentially with the size of the problem. Also, the variety of constraints typically found in embedded real-time systems makes it hard to devise an algorithm that can handle them all. These impediments have lead to that most allocation and scheduling algorithms relax the optimality requirement and provide only simple modeling constructs. As a consequence, of these simplifications many designs will be deemed as being infeasible, which means that the design process is prolonged due to unnecessary re-design iterations. Clearly, an approach that offers expressiveness in modeling as well as optimization algorithms with tractable run-time complexity, would be preferable. To this end, the concept of constraint programming can provide the requested features. That is, the problem is expressed using variables and arbitrary constraints that are managed by a constraint solver. The solver then employs various techniques to reduce the problem search space. In this thesis I have looked into various aspects regarding the application of constraint programming to the problem of optimal allocation and scheduling of real-time systems. The major contributions of this thesis are: C1. I propose a constraint taxonomy intended to provide a deeper understanding of the design restrictions that are present in embedded real-time systems. C2. I propose a method for modeling and solving the allocation and scheduling problem for embedded real-time systems using constraint programming. C3. I propose a set of guidelines for handling multiple objectives in arbitrary optimization problems. The aim of the guidelines is to achieve a fair balance between the objectives. 1

10 C4. I present an evaluation of a set of heuristics for allocation and scheduling in the context of constraint programming. The evaluation shows that there are combinations of heuristics that can reduce the average run-time by several orders of magnitude. The remainder of this thesis is structured as follows. Section 2 further explains the area of embedded real-time systems and the role of optimization in this context. This section also discusses possible design decisions and how they relate to the specific problem being studied. Section 3 then discusses various solution approaches and explains the constraint programming paradigm. Section 4 describes the particular research issues that I deal with, and Section 5 presents my results with respect to these research issues. Section 6 proposes future work and discusses the applicability of my results. Finally, the four papers on which the thesis is based, referred to as I, II, III and IV,are appended. 2

11 2 Background 2.1 Embedded Real-Time Systems Embedded real-time systems are special purpose systems designed to interact (through sensors and actuators) in a timely fashion with a well-defined environment. Due to the nature of typical embedded applications, the functionality of the system can be divided into a set of more or less independent components. In the design of the system it has to be decided whether a component should be implemented in hardware or software. However, the development of dedicated hardware components is often more costly than for software components. This is why the system architecture often comprises a network of commercial off-the-shelf processors on which software tasks are being executed. To achieve a correct overall behavior of the system, the tasks must be allocated and scheduled onto the hardware nodes in a suitable fashion. However, this process is not as easy as it might seem at a first glance. First, for the system to function as intended, there are a large number of constraints that restrict the behavior of the tasks. These constraints do not concern only the timing but also communication and resource usage. Second, the design of embedded systems is driven by contradicting objectives such as cost, power consumption, performance and dependability. Therefore, one solution may be considered superior to another although the design constraints are satisfied in both cases. Hence, it is desired that a found solution is optimal with respect to the design objectives. Optimization Loosely put, the idea behind optimization is to do something as good as possible. Formally, optimization involves defining an objective function f (x) that measures the quality of a solution x. A solution must be feasible, that is, satisfy the constraints that have been imposed on the problem. A feasible solution x Λ is optimal (assuming minimization) if f (x Λ )» f (x) for all feasible solutions. Hence, optimization involves searching the space of possible solutions. Optimization has been well studied within the areas of mathematics and operations research, leading to a number of theoretical results as well as algorithms. In this mathematical view, the problem is expressed as a set of variables, representing the solution, and a system of equations, representing the constraints. In the case of only linear equations and objective functions, and if the variables may be assigned real numbers, the Simplex algorithm [11] has been shown to have a low average run-time complexity for most applications. Unfortunately, for many problems the constraints and objective function are often nonlinear, making it necessary to introduce other techniques such as Lagrangian methods [10] that are computationally more expensive. Furthermore, the variables are often restricted to assume only integer values. For such problems, the selected method must be used as part of a higher level framework such as the Branch-and- Bound algorithm [8]. However, few problems naturally fit the mathematical modeling paradigm, which has lead to the development of specialized optimization algorithms 3

12 based on general optimization principles. For instance, the Branch-and-Bound algorithm has been applied to allocation and scheduling of real-time systems [1, 5, 6, 21]. The same goes for the local search method Simulated Annealing [12, 17]. The major disadvantage of these specialized algorithms is that it often becomes hard to introduce new constraint constructs or optimization objectives in an existing algorithm. Regardless of the selected optimization approach there are a number of issues that must be resolved. For example, how should a feasible solution be found? Once a solution is found it can be used to discard inferior ones and perhaps guide the search towards promising areas. Also, how do we know that a solution is optimal? Knowing this means that the search can be terminated. In many cases the whole search space must be examined but it is sometimes possible to make safe optimistic estimations. Finally, how should the objective function be defined? This is particularly tricky when there are several objectives to consider. These issues will be discussed more in detail in Section 4 and Section 5. The actual computational complexity of performing allocation and scheduling depends on the type of constraints that can appear. In general, allocation and scheduling is an NP-complete decision problem [3] which means that the corresponding optimization problem is NP-hard. In addition to the computational complexity, the variety of constraint constructs in embedded systems makes it difficult to devise an algorithm that handles them all. Therefore, traditional approaches to analysis of real-time systems consider only simplified problem models [22]. In particular, allocation and scheduling are frequently performed as two separate subsequent steps. This may have severe implications on the quality of the solution because, with a two-step approach, the result of the scheduling will depend on the allocation. In fact, there is a circular dependency since the probability of performing a good allocation would increase if knowledge about the scheduling phase was available. Furthermore, the constraints considered by the algorithm are only a subset of all the constraints that typically appear in embedded systems. Finally, most proposed approaches attempt to find only a feasible or good solution instead of an optimal. 2.2 Problem Space The design of an embedded system usually proceeds in an iterative top-down manner as illustrated in Figure 1. First, from the specification of the system, it has to be decided which functionality should be implemented as hardware components and which as software tasks. This hardware/software partitioning involves determining whether to use dedicated hardware or commercially available processors. Furthermore, the design constraints on the software tasks are imposed at this stage. Then, given a particular partitioning, it is the job of the allocation and scheduling to guarantee a correct functionality for the proposed solution. This makes it necessary to reason about implementation properties before the system is actually built. Thus, unknown properties 4

13 System specification Hardware/Software partitioning Hardware architecture & Software tasks Allocation & Scheduling Solution model Implementation Final product Figure 1: The design process. Parameter System architecture Schedulability analysis Run-time policy Values Fixed or Variable Off-line or On-line Priority-based or Time-triggered Table 1: Overview of the design space. such as task execution times, need to be estimated, either by using tools or from the experience of the designer. Eventually, during the implementation of the system, such as code writing and possibly hardware synthesis, it is verified whether the estimations were accurate. Obviously, some steps may have to be repeated several times due to modifications called for by the validation process. Recall that the purpose of allocation and scheduling is to achieve a correct behavior of the system. To reach this goal a number of assumptions must be made to define the specific problem space. Table 1 shows an overview of design decisions that affect the way allocation and scheduling of embedded real-time systems is performed. 5

14 System architecture The allocation and scheduling is the link between the specification and the implementation, causing the designer to make assumptions about what information is required to perform this activity. In a fixed architecture it is assumed that all necessary parameters are known (or estimated) to a fixed value. That is, the number (and characteristics) of the hardware components and software tasks. In a variable architecture these parameters may be unknown or known only to some extent. For instance, task execution times may be estimated using intervals and the hardware architecture may consist of a set of possible components. A variable architecture will probably reduce the number of design iterations because a solution will be more robust. However, this involves a more complicated analysis, especially because the allowed degree of variability must be determined. Therefore, I assume a fixed architecture and attempt to reduce the time required for each iteration in the design process. Schedulability analysis In soft real-time systems, such as video servers, the violation of a timing constraint is not critical but merely degrades the system performance. In these kind of systems it may be sufficient (and necessary) to perform only a simple online analysis to determine the timely execution of tasks. Because the analysis algorithm operates on-line it must not be too complex. Thus, the constraint model must be simple and the analysis should be based on rather pessimistic assumptions. Furthermore, the exact arrival pattern of the tasks during run-time is often unknown, making it difficult to give any absolute performance guarantees. In contrast, embedded systems have hard timing constraints that must be guaranteed to hold always. Hence, an off-line analysis is required before the system is started. To perform off-line analysis, the arrival pattern of the tasks must be known which typically also is the case for embedded systems. For an off-line algorithm, run-time performance is not crucial which allows for the use of a more sophisticated and less pessimistic schedulability analysis. Furthermore, this allows the system design to be optimized with respect to the relation between development cost and application functionality. Hence, I assume that correctness analysis of the allocation and scheduling must be ensured off-line. Run-time policy Given that the scheduling analysis must be performed off-line, there are two conceptually different ways to do this. In the first approach, the analysis may be done by verifying the behavior of an algorithm that on-line performs the allocation and scheduling as in fixed-priority scheduling. However, this verification is usually rather difficult, especially in the presence of complex constraints. The second approach is to generate a timetable (for each node) that dictates when tasks should start. This approach is well suited for complex constraints because an off-line algorithm is used to generate the timetable that is then simply checked to hold. It is also suited for optimization because different solutions can be easily compared. Therefore, I assume a time-triggered scheduling policy. 6

15 Problem statement Given the stated assumptions on the system architecture, runtime policy and schedulability analysis, I can now formulate the problem statement for the work in this thesis: How can an optimization algorithm for off-line scheduling of a time-triggered realtime system be devised such that (i) complex constraints can be used in system modeling and (ii) the computational complexity is reduced to a tractable level for typical applications? 3 Possible Approaches 3.1 Previous Work There have been several attempts to implement optimization algorithms for real-time scheduling problems. If the application constraints are simple and optimality is not required, a purely heuristic algorithm may be sufficient [2, 13, 14]. However, if optimality should be guaranteed, an optimization framework such as Branch-and-Bound [1, 5, 6, 21] is needed. The problem with the Branch-and-Bound approach is that it requires a so-called lower bound function to estimate the potential of a partial solution. For complex problem constraints, this lower bound function quickly becomes too complicated to be effective in practice. An alternative, more declarative, approach would then be the local search method Simulated Annealing [12, 17]. This algorithm traverses the search space randomly which means that, although a good solution may often be found, there is no guarantee that a feasible solution eventually will be found. Hence, for infeasible or tightly constrained problems, Simulated Annealing is of little use. A common disadvantage of Branch-and-Bound and Simulated Annealing is that they do not actively use knowledge of the constraints to reduce the search space. In contrast, this feature is present in the constraint programming paradigm that in addition combines the declarative modeling of Simulated Annealing with the systematic search of Branch-and-Bound. Constraint programming has recently been shown to be an interesting approach for allocation and scheduling of embedded real-time systems [15, 16]. For this reason, constraint programming will be the approach investigated in this thesis. 3.2 Constraint Programming From the previous sections, it was clear that the desired solution approach would have two, quite contradicting, properties. On the one hand, it should be possible to express arbitrarily complex constraints suitable for the problem. On the other hand, simple general constraints should be used to provide a base for mathematical reasoning about the problem model. These two concepts are in fact present in the constraint programming paradigm [18]. In constraint programming, the problem is expressed as variables and constraints similar to the mathematical programming paradigm. However, the reasoning employed 7

16 to solve a problem differs significantly. The values of the variables are not restricted to real numbers but can be from an arbitrary domain, such as integers, booleans or sets. Depending on the domains of the variables, different constraint solvers are used. Constraint programming has been applied to several combinatorial problems [19] and the perhaps most popular and successfully used model is that of finite (integer) domains. This domain is also well suited for the allocation and scheduling problem of embedded real-time systems because all events occur at discrete clock ticks. In practice, the constraint solver is usually embedded as a library in a general purpose programming language. The conceptual similarities between constraint programming and logic programming have made the integration of constraint solvers into languages such as Prolog the most popular choice. This combination is also known as constraint logic programming (CLP). The tool I have used in the work of this thesis is SICStus Prolog [9] and its library for finite domains, clp(fd). Modeling in clp(fd) means first declaring the the variables and their domains. Then, the constraints among the variables are announced to the solver. In addition to user-defined constraints, the constraint solver also offers a variety of predefined constraint constructs. The introduction of a constraint triggers a propagation mechanism to ensure that the variables are consistent with the set of defined constraints. That is, values that cannot be part of a solution are removed from the domains. If the domain of a variable becomes empty, the problem is deemed to be infeasible by the solver. Unfortunately, the constraint propagation is not complete, implying that, to find a solution (assignment of values to the variables), search is required. During the search, constraint propagation is also used, making active use of the constraints for search space reduction. In constraint programming, the concept of optimization is easily introduced by modeling the objective function as a constrained variable. Optimization is then obtained by iteratively solving the problem with increasingly tighter bounds on this variable. Example To illustrate the constraint programming approach, consider the following small example for allocation and scheduling. Assume that there are five tasks A; B; C; D; E and two processors p 1 and p 2. Assume further that D is not allowed to start executing before 10 time units have passed (from the start of the schedule) and E must not start before 25 time units 1. The worst-case execution times of the tasks are c A = 18;c B = 10;c C = 15;c D = 17;c E = 10. The tasks must finish before their deadlines which are d A = 36;d B = 10;d C = 25;d D = 35;d E = 35. In the model of this problem there are two variables for each task, representing the assigned processor N i 2 [1; 2] and the scheduled start time S i 2 [0; 1] 2. The constraints restricting the start times are S D 10;S E 25 whereas the constraints restricting the finish times are S i + c i» d i. Tasks are not allowed to overlap their executions unless they have been assigned different processors. This is modeled using a predefined constraint con- 1 This time is denoted r i for task i. 2 Domains may be declared as [ 1;1] as long as the posted constraints makes each domain finite. 8

17 d B d C d E r E B C E p t r D d D d A p 1 0 A 18 D 35 t Figure 2: A scheduling example. struct that ensures that a set of rectangles do not overlap. That is, each task is seen as a rectangle with its lower left corner in position (S i ;N i ), with width c i and height 1. The result of the propagation from these constraints gives the following (unique) solution: S A = 0;S B = 0;S C = 10;S D = 18;S E = 25;N i 2 [1; 2]. Hence, the schedule is found without search. However, for the allocation we need to search by guessing values for the N i variables. If N A := 1 we get N B = 2;N C = 2;N D = 1;N E = 2 and a feasible solution has been found. The solution for this example is displayed in Figure 2. In this particular example we get the same result regardless of what variable and value we choose. This is because there is actually only one solution to this allocation problem; the tasks B; C; E have to be on one processor and A; D on the other. However, because we have two (equal) processors we get two symmetric solutions. That is, if N A := 2 we get N B = 1;N C = 1;N D = 2;N E = 1. Despite the evident power of constraint programming displayed by the example, a number of questions arise. What type of constraints appear in a typical application and how can they be modeled? During the search, in what order should the variables and values be examined? How can different optimization approaches be incorporated and what are the typical optimization objectives? 4 Research Issues Given the optimal allocation and scheduling problem for embedded real-time systems and the chosen solution approach, constraint programming, a number of specific research questions can be identified. Addressing these issues involves combining knowledge from the areas of real-time computing, optimization theory and constraint programming. 9

18 Modeling Before the modeling can begin, it must be established which constraints that typically appear in embedded real-time systems. In particular, this includes grasping the meaning of the constraints to make the model as accurate as possible. Modeling then involves determining how to express the constraints in the constraint programming environment. This can sometimes be rather difficult, especially in terms of efficiency. Multi-objective There are several design objectives, such as communication and load balance, that are relevant for embedded real-time systems. The problem is how these objectives should be composed in a multi-objective optimization scheme. Hence, it has to be defined what is meant by an optimal solution in this context. Complexity reduction It is clear that the search algorithm requires application-specific heuristics to be efficient in terms of run-time. In order to devise good heuristics it is important to understand the composition of a typical application. Although the goal of all heuristics is to aid the search for a feasible solution, some may result in a better solution when considering a particular optimization objective. The question is which heuristics that work well for allocation and scheduling of embedded real-time systems. 5 Summary of Papers This section lists a summary of the appended papers and their major contributions. I Real-Time System Constraints: Where do They Come From and Where do They Go? Within the real-time literature a large number of allocation and scheduling algorithms have been proposed. Although they address similar problems, the system and task models are based on different assumptions. This is particularly true for the constraints that are considered by these algorithms. This short paper attempts to initiate a discussion on what constraints that are found in embedded real-time systems and why they exist. The purpose is to demonstrate that not all constraints correspond to the requirements on the system but have rather been fabricated to fit the allocation and scheduling algorithm. Furthermore, the discussed constraints illustrate the vast amount of constructs that indeed need to be considered by an algorithm. The paper suggests how to model the allocation and scheduling problem as a constraint satisfaction problem (CSP). That is, a problem formulation suitable for a constraint programming approach. 10

19 II Solving Embedded System Scheduling Problems using Constraint Programming This paper is a continuation of paper I in the sense that it proceeds with the discussion on the origins of embedded system constraints. However, this paper moves a bit further and presents a taxonomy of the constraints. The taxonomy classifies a constraint based on the properties that it governs but also, perhaps more importantly, on its origin. In short, a constraint is natural if it can be derived from the system requirements. An implementation constraint arises due to decisions that have to be made in order to build the system. Constraints that do not belong to these two categories are artificial and have been introduced to simplify the analysis of the system. That is, the design problem has been adapted to fit the allocation and scheduling algorithm. Clearly, artificial constraints should not be necessary and can cause the problem to be over-constrained if carelessly introduced. The taxonomy can therefore serve as a valuable guide when deciding which constraints to impose on the design. This paper also discusses the problems concerning multi-objective optimization that appear in embedded system design. That is, the design attempts to optimize several contradicting objectives. For example, the system should have a performance that is sufficient for the application but at a low level of power consumption. Hence, the question is how to combine several objectives into one overall definition of optimality. In this paper it is suggested that each individual objective function f i (x) is translated into a function g i (x) 2 [0; 100] representing the percentage reached P of the estimated 3 optimal value. The combined objective function is then f (x) = g i (x) subject to g i (x) min 8ifg i (x 0 )g where x 0 is the best solution found so far. To validate the constraint programming approach, this paper proceeds to evaluate the modeling capabilities as well as the run-time performance. The ease of use is illustrated by comparing constraint programming with Simulated Annealing in a small modeling example. The solution performance is demonstrated by applying constraint programming on a number of typical embedded system applications. In particular, the study shows how the introduction of various constraints affect the complexity of solving a specific problem. III A CLP Framework for Allocation and Scheduling in Embedded Real-Time Systems This paper relates to paper II (and I) in the sense that the typical embedded system constraints and objectives described in paper II, are now formally defined in a constraint satisfaction model. That is, this paper shows how to model the design constraints (and objectives) using the constraint constructs offered by the clp(fd) library in SICStus 3 The estimation has to be optimistic. That is, it guarantees that the optimum is never better than the estimated value. 11

20 Prolog. 4 To simplify the specification of an application, this paper defines a language based on typical embedded system concepts. It is then shown how this specification can be automatically translated into the constraint model. Furthermore, this paper includes a description of how to implement an optimization algorithm that enables (i) the search to be aborted at any time and return the currently best solution, (ii) several objective functions to be handled simultaneously (as explained in II), and (iii) the algorithm to be configured depending on the particular problem. Hence, whereas paper II addresses the ideas behind a framework based on constraint programming, this paper addresses the implementation details. IV Evaluation of Search Heuristics for Embedded System Scheduling Problems This paper differs from the previous ones in that it addresses the performance aspects of constraint programming rather than modeling issues. Despite the seemingly intractable complexity of NP-hard problems, it is in fact possible to reduce the average complexity significantly by using appropriate heuristics. Within the area of allocation and scheduling for embedded real-time systems, a number of such heuristics exist. However, there are also general constraint programming heuristics that are applicable to this particular problem. Hence, this paper proposes how to combine these different heuristics and also evaluates which combinations that are the most successful. For allocation, the following heuristics are investigated: communication-clustering, period-clustering, load-balancing, round-robin and depth-first. The performance of these allocation heuristics were tested using different optimization objectives such as maximum lateness, load balance and network communication. The results in this paper show that, in all cases, the communication-clustering heuristic resulted in the shortest algorithm run-time, the main reasons being that a reduction in network communication both simplifies the problem of message scheduling, and increases the slack present in the task scheduling. The performance of any allocation heuristic can be improved by the use of symmetry exclusion. That is, if the processors are equal, it is (in some cases) sufficient to try only one of them in an assignment of a task. In this paper it is shown that the combination of communication-clustering and symmetry exclusion in fact reduces the average algorithm run-time by several orders of magnitude. Furthermore, this paper investigates whether it, in the scheduling phase, is beneficial to find a consistent ordering of the tasks before assigning concrete start times. This has been suggested in other studies to shorten the scheduling time significantly. However, the simulations performed in this paper show that such a heuristic does not make a significant performance improvement for typical embedded real-time applications. 4 It should be noted that although constructs specific to this library have been used, these are present in most other finite domain solvers as well. 12

21 6 Discussion and Future Work The work performed in this thesis clearly demonstrates the applicability of constraint programming to the problem of allocation and scheduling of embedded real-time systems. In particular, it is shown that it is possible to allow complex modeling constraints and yet be able to reduce the average computational complexity. However, there are still improvements to be made in these two areas. Algorithm performance For any algorithm that solves NP-complete problems, intelligent heuristics are essential to achieve a reasonable performance. Therefore, new and better heuristics, application-specific or general, are still being proposed or can be expected to be proposed in the future. A recent example are the discrepancy-based search algorithms [4, 20] that attempt to combine systematic search with the idea of restart as used in many local search methods. The performance of any optimization algorithm is also dependent on the quality of the lower bound 5. So far, I have not used any lower bound functions but only relied on the bounds given by the constraint propagation that in many cases are too optimistic. Therefore, I intend to investigate whether there exist lower bound functions that can be applicable for the optimization objectives that I consider. Problem modeling A fast algorithm is not useful if the problem that it solves has no relevance (in the real world). It would therefore be interesting to investigate how well the framework proposed in this thesis actually fits into the design process. That is, what modifications of the problem model can be made to reduce the number of design iterations further. As already mentioned, one such improvement would be to increase the degree of variability in the model to make solutions more robust. For instance, task execution times could be specified as ranges rather than exact figures and a solution would then have to be valid for all values within the given interval. The robustness of a solution also depends on the constraints. By starting with a small set of constraints and gradually introduce more (or tighter) constraints as the design progresses, the model will not be subject to as many modifications by the designer. Therefore, it would be preferable for the designer to know what is the minimal set of constraints necessary to express the desired functionality. That is, whether there are any redundant constraints in the model. A related issue is what happens when a solution cannot be found. It would then be valuable for the designer to receive some hints on exactly what constraint that is violated and how it can be modified. In fact, the data necessary to support these features are, to some extent, already contained in the composition of the constraint solver [7]. Although these issues suggested for future work differ substantially, the common goal is the same: to simplify and speed up the design process for embedded real-time 5 The lower bound is the optimistic estimation of the optimal value assuming minimization. 13

22 systems. Furthermore, the constraint programming framework developed as a part of this thesis offers a good starting point for all the research directions mentioned above. Acknowledgments I am grateful to many people who have been helpful during the course of this research. First of all I thank my supervisor Dr. Jan Jonsson for always believing in me and my ideas. I would never have reached this far without his support and enthusiasm. I also thank the members of my evaluation group, Håkan Edler and Jonas Vasell, for helping me see how my work fits into the big picture. Of course, the friendly atmosphere provided by all the people at the department, especially you guys on the sixth floor, facilitated the work on this thesis. My roommates, Martin Hiller and Robert Feldt, deserve additional thank yous for helping me getting started as a graduate student. My deepest gratitude goes to my family, in particular Martin, for always encouraging me in moments of doubt. Finally, I send a thought to Juni who made me decide to take on computer science in the first place. This work was funded by ARTES ( the national Swedish Real- Time Systems research initiative, supported by the Swedish Foundation for Strategic Research. 14

23 References [1] T. F. Abdelzaher and K. G. Shin. Optimal combined task and message scheduling in distributed real-time systems. In Proc. of the IEEE Real-Time Systems Symposium, pages , Pisa, Italy, December 5 7, [2] S. Davari and S. K. Dhall. On a real-time task allocation problem. In Proc. of the IEEE Annual Hawaii International Conference on System Sciences, pages 8 10, Honolulu, Hawaii, [3] M. R. Garey and D. S. Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. Freeman, New York, [4] W. D. Harvey and M. L. Ginsberg. Limited discrepancy search. In Proc. of the International Joint Conference on Artificial Intelligence, Montreal, Canada, August 20 25, [5] C.-J. Hou and K. G. Shin. Allocation of periodic task modules with precedence and deadline constraints in distributed real-time systems. IEEE Trans. on Computers, 46(12): , December [6] J. Jonsson and K. G. Shin. A parametrized branch-and-bound strategy for scheduling precedence-constrained tasks on a multiprocessor system. In Proc. of the Int l Conf. on Parallel Processing, pages , Bloomingdale, Illinois, August 11 15, [7] N. Jussien and V. Barichard. The palm system: explanation-based constraint programming. In Proc. of TRICS:Techniques for Implementing Constraint programming Systems, Singapore, September [8] W. H. Kohler and K. Steiglitz. Enumerative and iterative computational approaches. In E. G. Coffman, Jr., editor, Computer and Job-Shop Scheduling Theory, chapter 6, pages Wiley, New York, [9] Intelligent Systems Laboratory. SICStus Prolog User s Manual. Swedish Institute of Computer Science, [10] S. G. Nash and A. Sofer. Optimality conditions for constrained problems. In Linear and Nonlinear Programming, chapter 14, pages McGraw-Hill, [11] S. G. Nash and A. Sofer. The simplex method. In Linear and Nonlinear Programming, chapter 5, pages McGraw-Hill, [12] M. D. Natale and J. A. Stankovic. Scheduling distributed real-time tasks with minimum jitter. IEEE Trans. on Computers, 49(4): , April

24 [13] K. Ramamritham. Allocation and scheduling of precedence-related periodic tasks. IEEE Trans. on Parallel and Distributed Systems, 6(4): , April [14] K. Ramamritham, J. A. Stankovic, and P.-F. Shiah. Efficient scheduling algorithms for real-time multiprocessor systems. IEEE Trans. on Parallel and Distributed Systems, 1(2): , April [15] K. Schild and J. Würtz. Scheduling of time-triggered real-time systems. Constraints, 5(4): , October [16] R. Szymanek, F. Gruian, and K. Kuchcinski. Digital systems design using constraint logic programming. In Proc. of the Practical Application of Constraint Technology and Logic Programming, Manchester, England, April 10 12, [17] K. W. Tindell, A. Burns, and A. J. Wellings. Allocating hard real-time tasks: An NP-hard problem made easy. Real-Time Systems, 4(2): , June [18] E. Tsang. Foundations of Constraint Satisfaction. Academic Press, [19] M. G. Wallace. Practical applications of constraint programming. Constraints, 1(1), [20] T. Walsh. Depth-bounded discrepancy search. In Proc. of the International Joint Conference on Artificial Intelligence, Nagoya, Japan, August 23 29, [21] J. Xu and D. L. Parnas. Scheduling processes with release times, deadlines, precedence, and exclusion relations. IEEE Trans. on Software Engineering, 16(3): , March [22] J. Xu and D. L. Parnas. On satisfying timing constraints in hard-real-time systems. IEEE Trans. on Software Engineering, 19(1):70 84, January

25

26 Paper I Real-Time System Constraints: Where do They Come From and Where do They Go? Reprinted from Proceedings of the International Workshop on Real-Time Constraints October, 1999.

27

28 Paper II Solving Embedded System Scheduling Problems using Constraint Programming Reprinted from Technical Report Department of Computer Engineering Chalmers University of Technology Göteborg, Sweden, 2000 Submitted for Publication.

29

30 Paper III A CLP Framework for Allocation and Scheduling in Embedded Real-Time Systems Reprinted from Technical Report Department of Computer Engineering Chalmers University of Technology Göteborg, Sweden, 2001 Submitted for Publication.

31

32 Paper IV Evaluation of Search Heuristics for Embedded System Scheduling Problems Reprinted from Proceedings of the International Conference on Principles and Practice of Constraint Programming November/December, 2001.

33

34