Robert T. Casey
EEL 270-RTOS
Spring 2007
A Survey of Fuzzy Scheduling Algorithms
Scheduling algorithms may be considered one of the key components of a real-time
system, specifically in an RTOS, which can either enable the system to thrive or bring it to its
knees. Consider the simple priority inversion blunder of the Mars Rover in 1997 which crippled
a significant portion of that mission [1]. This example clearly demonstrates the careful
consideration which must be given to every aspect in the design of a real-time embedded system.
Strict timing requirements must often be met within highly dynamic environments which do not
lend themselves well to static scheduling algorithms. The level of uncertainty in dynamic, realtime environments is such as to require significant flexibility and adaptivity from an embedded
system. Fuzzy systems fit this requirement, falling under the umbrella of the nascent field of soft
computing, which seeks to merge the efforts of neural networks, evolutionary computing,
probabilistic techniques, and chaos theory. A fuzzy scheduling algorithm builds into the realtime system flexibility and adaptation to the uncertainty inherent in real-time environments and
offers a means to improve several important characteristics of real-time systems. This paper
offers a brief, but informative, survey of a few reasonably successful attempts to extend popular
scheduling algorithms to a fuzzy model. As a point of clarification, this paper will focus on
short-term scheduling - that scheduling which executes most frequently and makes the finegrained decision of which process to execute first [2].
The first paper reviewed, Real-Time Scheduling using Fuzzy Techniques, was not
associated with a particular conference or journal, but was referenced in CiteSeer.IST [3].
Pettersson presents a limited survey of real-time scheduling algorithms using fuzzy techniques
and serves as an adequate introduction to some of the key concepts behind fuzzy scheduling
algorithms.
The author begins with a general overview of fuzzy set theory, membership functions,
and linguistic variables. This material is important to those with limited exposure to fuzzy set
theory. The first example presented covers the set of real numbers close to 7. Classical set
theory would provide a membership function akin to a step function whose value is 0 for x < 6
and x > 8, and with value 1 for 6 <= x < = 8. By contrast, the fuzzy membership function (MF)
is a continuous function possessing fractional degrees of membership. In this example, the graph
of this function represents a triangle whose left edge is a line of increasing slope, beginning at x
= 5.5 and y = 0. At x = 7, the vertex of the triangle, the triangle's right edge appears as a
decreasing linear function until it reaches the next vertex, at x = 8.5 and y = 0. The fuzzy model
of a MF does not feature hard boundaries between membership and non-membership. Instead, it
more closely models the uncertainty inherent in language constructs by approximating
membership through reasonably determined domains, such as 5.5 <= x <= 8.5 in this example.
Next the author covers linguistic variables and how fuzzy sets can be used to model such
descriptions as “very young, young, old, and very old.” This introductory material is fairly
sparse, but may help those with no previous exposure to fuzzy sets grasp the techniques used in
the scheduling algorithms later presented.
The author mentions the real-time scheduling characteristics most nearly concerned with
uncertainty: the execution time of tasks and the umbrella category of ”real-time constraints,”
All content © 2009 DigiPen (USA) Corporation, all rights reserved.
under which deadline, ready time, task period fall. The “most obvious place” to introduce fuzzy
concepts for modeling uncertainty in scheduling algorithms is with a task's execution time.
Typical scheduling algorithms assume this information to be a priori; this may or may not be
reliable. Upon consideration of such a static specification, one questions the flexibility of such
an approach, for example, if the environment quickly changes state. By modeling the execution
time of a task with a fuzzy number, a system designer can build flexibility into the scheduling
algorithm and adapt to such changes more adeptly. The previous points highlight one of the
paper's strengths.
The first paper reviewed by Pettersson, A Fuzzy Rule-Based Approach to Real-time
Scheduling, will be reviewed in depth at later by the author [4]. Pettersson's examination
presents a brief overview of some of the high points of Lee's work and provides a muchappreciated service by reprinting legible copies of figures from Lee's paper which were mostly
indecipherable in the online reference document. These figures covered the membership
functions for laxity as well as criticality; laxity included the fuzzy sets of “early,” “medium,” and
“late,” while criticality (task importance) included the fuzzy sets of “important,” “average,” and
“unimportant.” As a side note, it would be curious to see what tasks were deemed as
unimportant! After all, if a task is unimportant, then why create it? Perhaps more descriptive
labels for the fuzzy sets in question might be “high priority,” “medium priority,” and “low
priority.” But this is critiquing Lee's work, rather than Pettersson's, a discussion to be had later.
Pettersson mentions Lee's two goals: 1) maximize the number of tasks being scheduled,
and 2) minimize the number of important tasks lost upon system overload; however, he misses
the notion that these goals may conflict. Also, goal (1) comes across as vague; is a task which is
“scheduled” actually completed? If this was the author's intent, then he describes Lee's work in a
manner which agrees with what this author has surmised regarding Lee's work. If, however, the
statement of goal (1) means simply that the task is piped into the ready queue or some other state
of affairs, then he misses the mark, in this author's opinion. Lastly, the author mentions that
Lee's algorithm is used for dynamic real-time scheduling and assumes a nonpreemptive
scheduling architecture. However, the author fails to mention to the reader what dynamic
scheduling entails other than that the Minimum Laxity First (MLF) algorithm is an example of
such; simply mentioning that dynamic scheduling involves run-time priority calculations would
have been sufficient and helpful.
A fairly significant omission in Pettersson's coverage of Lee's work is that Lee
incorporated two versions of the MLF algorithm when generating comparisons against the fuzzy
scheduling algorithm. Lee observed that the MLF algorithm does not take into account the task's
priority (criticality), thus the initial comparison of an unmodified MLF against the fuzzy
scheduler might unfairly place favor with the fuzzy algorithm, since it takes into account a factor
which the MLF does not. To be more nearly fair, the authors of A Fuzzy Rule-based Approach to
Real-time Scheduling extended the MLF in two ways: a weighted version and an averaged one.
According to Lee, these extensions improved the performance of the core MLF algorithm,
however, the fuzzy scheduler still performed better, which lends even greater credibility to the
fuzzy approach.
The next paper mentioned in Pettersson's survey, Fuzzy Concepts Applied to Preemptive
Real-time Tasks Scheduling by Mendoca, et al, features a deadline constraint rule which has been
fuzzified. In this author's (RTC) limited knowledge, to “fuzzify” a number or a rule means to
map a classical mathematical relation or number to one expressed with a fuzzy set or relation,
either by MF generation or using a tool such as the extension principle [5]. Pettersson mentions
2
a function called the “satisfaction index” which seems to correspond to a hypothetical fuzzy set
labeled “possible finishing time for the task,” related to a scheduling criterion in Mendonca's
work.
The author glosses over any results presented in the paper reviewed: “Mendonca et al
(1996) claims that the schedule obtained by this algorithm takes advantage on the good
properties of existing algorithms and automatically chooses the algorithm providing the best
schedule.” The previous sentence raises more questions than it answers. First, which properties
are optimized or utilized for advantage? The deadline scheduling criteria? Also, it is doubtful
(though not impossible) that Mendonca would have stated something to the effect of “this
schedule automatically chooses the algorithm providing the best schedule,” unless a proof was
provided or the tasks of interest were of trivial running time, limited priority range, and short
execution time. Otherwise, a “best schedule” is more of a goal than an absolutely realizable
state, just as the “fastest computer” is more of an abstraction than a concrete entity.
Lastly, Pettersson mentions the work of Ishibuchi, et al, entitled Formulation of Fuzzy
Flowshop Scheduling Problems with Fuzzy Processing Time. A flowshop perhaps deals with the
problem of scheduling n jobs on m machines, thus introducing multiprocessor scheduling. The
author describes very briefly how Ishibuchi's work includes a multi-objective genetic algorithm
to find an optimum scheduling algorithm, using such properties as maximum delay and total
delay.
In summary, Pettersson provided an adequate overview of a few fuzzy scheduling
techniques which have been developed recently. The shortcomings previously mentioned lie in
the fact that the paper is, itself, just an overview or survey of a few techniques and was not
intended to provide an in-depth discussion of a broad range of fuzzy scheduling techniques.
Given Pettersson's introduction, let us now turn our attention to a more in-depth
discussion of Lee, Tiao, and Yen's IEEE paper, A Fuzzy Rule-based Approach to Real-time
Scheduling [4]. Conventional real-time scheduling algorithms suffer from one common
problem: all constraints, such as computation times and deadlines, need to be known exactly
before the algorithm can schedule the tasks. Thus the system suffers from a sort of “crystal ball”
syndrome: the system itself should have the capability of predicting the computation times and
deadlines before the tasks are really executed or it should be able to use with a high-degree of
confidence the statically-provided estimate provided by the user or task creator. This approach
relies on assumptions which may not necessarily hold water in all possible cases, especially in
dynamic real-time environments. Even statistical estimation methods such as exponential
averaging, though potentially accurate, are always “playing catch-up” rather than simply
embracing the uncertainty which exists regarding these variables; also, these techniques may not
be suitable in many practical situations. The inflexibility of constraints could be alleviated by
using soft constraints in the scheduling algorithms. The authors admit that although such a
dynamic scheduling system as the one they propose does have higher run-time costs than a
similar static system, their system is more flexible and can easily adapt to the changes in the
environment, thus illustrating robustness as a real-time system. The authors seem quite adept in
the realm of soft computing, which is detailed eloquently by the founder of fuzzy set theory,
Lotfi A. Zadeh:
The essence of soft computing is that unlike the traditional, hard computing, soft computing is aimed at an
accommodation with the pervasive imprecision of the real world. Thus, the guiding principle of soft
computing is to exploit the tolerance for imprecision, uncertainty, and partial truth to achieve tractability,
robustness, low solution cost, and better rapport with reality [6].
3
Specifically, the authors' approach involves a non-preemptive, uniprocessor solution
which utilizes a set of fuzzy rules to derive a feasible schedule. A “feasible schedule” is defined
as one which contains all tasks and in which all tasks meet their deadlines; thus a feasible
schedule is an ideal schedule. In addition to the goal of a feasible schedule, the authors seek a
graceful degradation of system performance upon overload, thus enhancing its robustness.
Ideally, a system will allow higher priority tasks to run upon overload and not drop an
unacceptably high number of important tasks.
In the vein of many good research papers, the authors preface their work with a review of
similar work in the field of real-time scheduling. They give credit to the significant work by Liu
and Layland on the rate monotonic scheduler (RMS) as well as the minimum laxity first (MLF)
algorithm [7].
The challenge addressed by Lee, et al concerns the “difficulty of developing a feasible
and reliable scheduling algorithm.” Their setup involves a system handling a set of aperiodic
tasks with more or less random arrival times. Periodic tasks are also handled, but each as an
instance of an aperiodic task; this clever twist presumably simplifies a few implementation
details.
At this point the authors delve into the meat and math of their approach. Decision
alternatives are mentioned, which are basically an execution sequence of various tasks. For
example, the notation T1 > T2 > T3 means that T1 runs first, then T2, followed by T3. To
appreciate the enormity of the decision tree faced by scheduling algorithm designers, consider
that for n tasks, there exist n! decision alternatives. Also, the authors briefly discuss an idea
called “aggregation of judgments,” which is a process of obtaining the overall decision or
conclusion from the individual contributing rules.
The authors treat the real-time scheduling problem as a multi-criteria optimization
problem. The task constraints which are chosen to represent linguistic fuzzy variables are laxity
and criticality (priority). The corresponding MFs for these variables were discussed previously
in the above section on Pettersson's paper. The laxity of a task represents the maximum time that
a task can wait before being executed ( deadline – computation time - arrival time). Laxity can
be seen to be a measure of flexibility, or perhaps “clever laziness.” Again, the goals of the fuzzy
scheduler are as follows:
1.
2.
Maximize the number of tasks being executed, and
Minimize the number of important tasks being lost if the system is overloaded.
Note that goal 1 and 2 may conflict with one another. According to a source in Lee's paper, there
are two stages to multi-criteria optimization:
1. The aggregation of the judgments with respect to all goals and per decision alternative, and
2. the rank ordering of the decision alternatives according to the aggregated judgments.
At this point, the authors essentially use advanced fuzzy logic inference rules as well as
combinational techniques to select the task to execute first.
Now let us discuss the authors' tested results using a simulation model and performance
metrics to demonstrate the effectiveness of their solution. First, it should be noted that the tasks
in the test cases were assumed to be aperiodic and to follow what is called a Poisson distribution
in regards to their arrival rate. The Poisson distribution is a discrete probability distribution
which expresses the probability of a number of events occurring in a fixed period of time if these
4
events occur with a known average rate, and are independent of the time since the last event [8].
The performance metrics used included task loss ratio ( number of lost tasks / number of tasks
arrived ) and average weight loss (total weight of lost tasks / number of lost tasks ), where a
task's weight is its priority. The team then compared its fuzzy scheduler with a standard MLF
algorithm. For “uniform” tasks (uniform with respect to which property?), the task loss ratio of
the fuzzy algorithm approximated the optimal MLF. For the average weight loss metric, the
fuzzy algorithm performed significantly better. For nonuniform tasks, the fuzzy algorithm
performed better across the board. As mentioned previously, the “traditional” MLF algorithm
does not take into account the task's priority (criticality), so the authors extended it to include this
factor. The fuzzy scheduler showed improvements over even this enhanced version.
Overall, I was impressed with the authors' work. It was apparent that the team was highly
confident in its approach; the fact that they essentially “bulked up” the competition through their
MLF extension and then showed that their fuzzy scheduler outperformed even that was a
convincing demonstration of the power of their approach. Additionally, their explanation was
concise. One of the few limitations of the paper concerns the poor print quality of the figures
and graphs. This was most likely a result of the archiving process and not directly related to the
authors' efforts. It did, however, make gathering any information from these graphs next to
impossible; in the end I was forced to more or less trust the authors' verbal description of their
results.
In the next paper reviewed, entitled Scheduling Non-Preemptive Periodic Tasks in Soft
Real-Time Systems Using Fuzzy Inference, the authors introduce a novel scheduling algorithm:
highest fuzzy priority first, whose performance is matched with a nonpreemptive version of the
Earliest Deadline First (EDF) algorithm [9]. Sabeghi, et al begin with a general introduction to
the differences between an RTOS and a GPOS, hard vs. soft real-time systems, periodic vs.
aperiodic tasks, the basic ideas behind scheduling, as well as preemption vs. non-preemption.
The authors chose to implement a non-preemptive solution to real-time scheduling for the
following reasons:
1. I/O scheduling makes preemption either extremely challenging or prohibitively
expensive.
2. Easier to implement than preemptive.
3. Non-preemption on a uniprocessor system guarantees exclusive access to shared
resources and data, eliminating the need for synchronization primitives such as
semaphores, mutexes, etc. and avoids the associated overhead.
4. Lower runtime overhead,
important points to consider when designing scheduling algorithms.
Next, the authors provide a general overview of Fuzzy Inference Systems, as well as core
fuzzy material. There are three main stages to a Fuzzy Inference System(FIS): input,
processing, and output. The input stage maps the inputs to the appropriate membership functions
and corresponding fractional truth values. The processing stage uses a rule engine, database, or
knowledgebase to map the membership functions of the input to those of the output; the
processing also involves an aggregation or combination of the results of the rules. Finally, the
output stage converts the fuzzy output to a crisp value or singleton. The authors provide the
following example of a fuzzy inference (IF-THEN) rule: IF deadline is critical THEN priority is
very high. The authors also give an excellent introduction to two common fuzzy inference
methods - the Mamdani method and the Takagi-Sugeno-Kang method, usually noted as the
Sugeno inference method.
5
After this brief lesson on inference methods, the authors return to the topic at hand, their
own work, and mention that they will not be considering either of the previous techniques and
will be, instead, developing an alternative. This alone would have been acceptable until an
observant reader notices that, in the diagram of their Inference System, Fig. 1, the block
containing the Fuzzy Inference Engine has a label in parentheses of “(sugeno)”! One might infer
deception, confusion, or poor editing skills. I am slightly surprised that the IEEE did not catch
this mix-up when reviewing the paper.
At any rate, the authors' fuzzy inference engine seems to take the following inputs to be
translated to fuzzy sets: deadline and “external priority.” External priority is the priority
assigned to the task “from the outside world,” assumed to be the user or task creator. The
authors later point out that this priority is assigned according to a rate monotonic approach (the
shorter the task, the higher its priority). Some confusion arises when the authors, upon
presenting their fuzzy set for Epriority (external priority), mention that “The shape of the
membership function for each linguistic term is determined by the expert. It is very difficult for
the expert to adjust these membership functions in an optimal mode.” What expert? Is the
expert some processing function in the fuzzy inference engine? A little more detail in this area
may have strengthened this part of the paper. The authors conclude the section on their fuzzy
inference system with five of the eleven rules in their system, such as “If (Deadline is sufficient)
and (EPriority is high) then (Priority is normal).” They also include a beautiful and informative,
color 3-D graph of the “decision surface” corresponding to the inference rules in their system.
The decision surface seems to be an all-at-once mapping of the two fuzzy variables, Epriority
and Deadline, to the final priority.
Sabeghi, Naghibzadeh, and Taghavi then present the pseudocode for their Highest Fuzzy
Priority First (HFPF) algorithm. Essentially, the algorithm pipes the epriority and deadline data
into the inference engine, which crunches these numbers according to the fuzzy rules. Next, the
inference engine produces a crisp priority for each task, and the task with the highest priority is
then executed.
The last section of the paper discusses the results of the HFPF algorithm compared to a
standard version of EDF. This section begins with a brief discussion of the performance metrics
the authors consider relevant to scheduling algorithms. These metrics include response time,
number of missed deadlines, number of successfully met deadlines, CPU utilization, and number
of missed high-priority deadlines.
Testing of the two algorithms involved 2500 test cases with load factors less than one.
Load factor might represent the ratio of the average load over a specific period of time compared
to the peak load; thus a load factor greater than one would indicate an overloaded system. The
authors provide figures comparing the EDF algorithm to the HFPF (oddly labeled as MFDF)
algorithm for each of the metrics previously mentioned. These graphs clearly demonstrated the
effectiveness of the authors' work; the HFDF algorithm seemed to miss fewer deadlines,
regardless of priority, and meet more deadlines. In the realm of CPU utilization as a function of
the load factor, the two algorithms performed nearly identically. For response time as a function
of the load factor, HFPF performed better than EDF for overloaded systems, when the load
factor exceeded about 1.7. For smaller load factors, the EDF algorithm provided better response
time.
In the authors' conclusion, they mention that their fuzzy scheduling algorithm better
utilizes system resources such as the CPU. However, Fig. 7 in their results, in which CPU
utilization is depicted as a function of the load factor, shows a utilization plot nearly identical to
6
that of EDF, thus this conclusion was not demonstrated to be valid. The authors conclude their
paper with a brief hint of future work in improving their system, namely utilizing rule reduction
techniques and adjustments to the membership functions through adaptive methods of inference.
Despite the typographical errors and points of confusion previously mentioned, this paper
was one of the more cohesive ones reviewed. The introductory exposition was concise and
relevant, the project goals were clear and well-founded, and the results were compelling and
clearly demonstrated. The paper was also quite straightforward to understand, for the most part.
The next paper presents a higher degree of mathematical formalism in the absence of
experimental results. Entitled Fuzzy Calculus Applied to Real Time Scheduling, the authors
François Terrier and Ziqiang Chen also discuss an extension to the EDF scheduling algorithm in
the context of fuzzy systems [10]. Terrier and Chen present the familiar argument in favor of
fuzzy scheduling, emphasizing the flexibility under uncertainty which could prove advantageous
to real-time systems. The authors also delve into some of the concerns of real-time applications,
mentioning hard and soft systems and then elucidating a few typical real-time scheduling
constraints. The authors make a good point by stating that often no assumption is made
regarding task communications for scheduling determinations, which, upon consideration, could
certainly have an impact on task performance if such communication was not designed
intelligently. At any rate, like Lee's paper, this paper references the work of Liu and Layland
regarding hard scheduling algorithms [7]. Seeing this reference twice now in my survey, I
gathered that it might be worth a quick perusal. A quick look showed a heavy theoretical
grounding with plenty of theorems and proofs on various task-related specifics. For example,
Theorem 7 regarding the Rate Monotonic Scheduler is listed as follows:
For a given set of m tasks, the deadline driven scheduling algorithm is feasible if and only if
(C1/T1) + (C2/T2) + ... + (Cm/Tm) <= 1
with a proof thereafter which extends to cover one and one-half pages. The inclusion of this
reference lends some credibility to Terrier and Chen's paper.
The authors then begin a discussion of schedulability criteria, including the fuzzy
variables of task execution time and a more general, umbrella term called “real-time constraint
definition.” The task execution time, in general, may vary (loops, branches, etc.), though O(n)
notation helps focus prediction; the changing nature of real-time conditions may cause execution
time to vary even more, especially for I/O bound processes. Real-time constraint definition deals
more with the context and manner in which a task is executed; variables such as task period,
response time, and a task's relative importance fall under this umbrella term.
Next the authors delve into their extension of the EDF schedulability criteria, tossing
around various pieces of mathematical notation and terms such as Possibility (Π) and Necessity
(N) as well as a possibility distribution function, which seems to correspond to the concept of a
membership function. A broader and deeper fuzzy and classical mathematical background could
have helped me further understand what Terrier and Chen were presenting; currently, much went
over my head. The authors apparently used triangular possibility distributions for (perhaps) the
fuzzy variables of the task execution time as well as task period. After a little digging, I was able
to surmise that the authors construct for each task a characteristic variable composed of a fuzzy
ratio of the task execution time divided by its period. What is done with this ratio, labeled xi,
remains a mystery.
In their final exposition on the EDF Algorithm Extension, Terrier and Chen seem to raise
more questions than they answer regarding the solution “obtained.” This is not altogether a bad
7
approach; the implementation of many fuzzy algorithms may be straightforward, while the
implications behind the resulting solution may not be. However, the authors' writing style is not
entirely lucid, and though they raise a few important questions, it was difficult to hack through
the verbal jungle of their paper and extract these questions. These questions concern “what a
fuzzy period means” as well as “what guarantees can be made on the correctness and optimality
of the fuzzy solution?” The authors point out that the current time has to be considered as a
fuzzy variable and that the “usual” results of fuzzy arithmetic may be applied to the task ready
time, the current time, and the sum of the current time and the execution time.
In summary, Terrier and Chen present a mathematically oriented approach to developing
a fuzzy extension to the EDF algorithm. Their line of reasoning is a little tough to follow, their
command of the English language not the most compelling. Additionally, no implementation of
the algorithm which they “developed” was presented, thus no tests as to the effects of such an
algorithm could be presented. From an engineer's perspective, this could be seen to weaken the
paper; from a mathematician's or theoretician's perspective, it could be seen to strengthen it!
This author leans more towards the engineer's perspective.
The final paper in this survey, like the paper on the HFPF algorithm, also originates from
researchers at the Ferdowsi University of Mashhad in Iran. The title of the paper is Evolutionary
Fuzzy Real-Time Job-Shop Scheduling [11]. The three researchers, Hosseini-Rostami,
Akbarzadeh-T, and Sadati-Rostami, employ genetic algorithms (hence the “Evolutionary” in the
title) to tune the fuzzy membership functions developed in their scheduling algorithm. Like Lee,
the authors consider real-time scheduling as a multi-criteria optimization problem. In fact, the
paper later unravels into a side-by-side comparison with a genetic algorithm-optimized extension
of Lee's work.
The authors begin with an overview of real-time systems, discussing the static and
dynamic task scheduling and the higher initial development costs of dynamic scheduling vs.
static scheduling. After a brief overview of Lee's work, the authors segue into their own by
introducing a new linguistic variable, computation time (CT). This variable represents the time
required to handle a given task, or its runtime, and was introduced to act as a tie-breaker within
their hierarchical fuzzy decision-making process. The setup is as follows: when multiple tasks
have equal laxity and importance, jobs with smaller CT's will be executed first, and hence the
number of completed jobs will increase. This resembles rate monotonic scheduling, but using
task runtime rather than period as the deciding factor.
Next, Hosseini-Rostami, et al provide an overview of the minimum laxity first (MLF)
scheduling algorithm, a dynamic programming approach to handle scheduling in overloaded
environments. Dynamic programming may be seen as a broader and more complicated topic
than dynamic scheduling; a few key points are that it makes use of overlapping subproblems,
optimal substructure, and memoization [12].
The authors' fuzzy approach treats task laxity and importance as linguistic variables.
Laxity is further subdivided into the fuzzy sets “early,” “medium,” and “late;” importance is
segmented into the fuzzy sets “important,” average,” and “unimportant.” Finally, the fuzzy
variable for computation time branches into the three fuzzy sets “much,” “medium,” and “small.”
The graphs of the membership functions representing these fuzzy sets strains the eyes a bit, but
with effort a few sigmoids and perhaps Gaussian distributions may be inferred. These
membership functions were reportedly “experimentally determined,” which makes one wonder.
The goals behind the authors' priority assignments focus on defensive, damage control:
1) lose fewer tasks, and 2) lose fewer important tasks. Goal 1 differs slightly from Lee's:
8
Maximize the number of tasks being executed. Lee's goals seem more aggressive.
The authors' inference system revolves around a two-stage, hierarchical fuzzy decision
maker. Within this system, importance and laxity contribute to the primary priority level; this
result is then combined with the fuzzy variable CT to determine the final priority level. Genetic
algorithms (GA) come into play by somehow filtering or enhancing the results obtained from the
1st and 2nd level decision makers.
My exposure to GA techniques is limited, so my commentary may not be the most wellinformed. At any rate, the authors seemed to test a particular “population” of tasks or task-sets
to begin with. From that round, the best performers are chosen through “stochastic sampling,”
which is essentially at random, through equally spaced members. “Offspring” are then created
by linear recombination of some sort and mutation; specific details of this process were omitted.
The team's “fitness function” (to test how well a member did) follows: f = N + I, where N = total
number of executed tasks, and I = average importance of executed tasks. New membership
functions are generated after the GA-optimizations. What impressed me about the team's
approach is that they applied GA not only to their own algorithms using the three constraints, but
also to Lee's two-constraint MF's as a manner of competition.
In the end, the team wrapped up their paper with very terse conclusions and less than
compelling graphs of their results. To their credit, the team did at least mention that their
approach facilitated more tasks to be completed overall and more important tasks to be
completed in particular. Like the previous paper, the graphs were of poor print quality and
difficult to decipher, this time due to their tiny size. The authors indicated using Matlab with its
Fuzzy Logic Toolbox as well as the Genetic Algorithm Toolbox, thus the potential for
compelling graphs existed.
In summary, this team's writing and result-reporting came across as average to aboveaverage. Their experiments and the concepts behind their experiments exceeded those in the
previously reviewed papers in this survey. I would imagine their work holds tremendous
potential in the realm of optimized real-time scheduling algorithms in overloaded environments,
perhaps in the field of intelligent real-time agents or systems. Learning algorithms might form
the core of much future programming, with little human intervention. A promising project might
involve using the GA techniques presented in this final paper to optimize the membership
functions in the HFPF described by Sabeghi for perhaps even greater improvements. At any
rate, this team's current approach seems to make excellent use of computational intelligence tools
coupled with the soft computing approach available through fuzzy sets and logic.
9
References
[1] Jones, Mike. “What Really Happened on Mars?”
http://research.microsoft.com/~mbj/Mars_Pathfinder/Mars_pathfinder.html
[2] Stallings, William. Operating Systems: Internals and Design Principles. New Delhi:
Prentice-Hall of India, 2005.
[3] Pettersson, Lennart. “Real-time Scheduling using Fuzzy Techniques,”
http://citeseer.ist.psu.edu/5487.html
[4] Lee, J. et al. “A Fuzzy Rule-Based Approach to Real-Time Scheduling,” Proceedings of the
Third IEEE Conference on Fuzzy Systems: IEEE World Congress on Computational
Intelligence, Vol. 2, Pages 1394 - 1399, 26-29 June 1994.
[5] Klir, George J. et al. Fuzzy Set Theory: Foundations and Applications. Upper Saddle River:
Prentice Hall PTR, 1997.
[6] Jang, J.-S.R., et al. Neuro-Fuzzy and Soft Computing: A Computational Approach to
Learning and Machine Intelligence, Upper Saddle River: Prentice Hall, 1997.
[7] Liu, C.L., Layland, James W. “Scheduling Algorithms for Multiprogramming in a HardReal-Time Environment,” Journal of the ACM, Vol. 20, Issue 1, Pages 46-61, January 1973.
[8] http://en.wikipedia.org/wiki/Poisson_distribution
[9] Sabeghi, M. et al. “Scheduling non-preemptive periodic tasks in soft real-time systems using
fuzzy inference,” Ninth IEEE International Symposium on Object and Component-Oriented
Real-Time Distributed Computing, 6 pp., 24-26 April 2006.
[10] Terrier, F.; Ziqiang Chen. “Fuzzy Calculus Applied to Real Time Scheduling,” Proceedings
of the Third IEEE Conference on Fuzzy Systems: IEEE World Congress on Computational
Intelligence, Vol. 3, Pages 1905-1910, 26-29 June 1994.
[11] Hosseini-Rostami, S.M., et al. “Evolutionary Fuzzy Real-Time Job-Shop Scheduling,”
Proceedings of the World Automation Congress, Vol. 18, Pages 431-436, 28 June 2004.
[12] http://en.wikipedia.org/wiki/Dynamic_programming
10