Conference PaperPDF Available

A new technique of switch & feedback job scheduling mechanism in a distributed system.



In this paper we investigate on a special type of job scheduler for distributed heterogeneous systems called the switch and feedback job scheduler. The main objective of the centralized job scheduler is to achieve maximum performance with reduced waiting time and faster response time for independent tasks by reordering the processor queue list based on the feedback received from each individual local processing system.
Keywords: Parallel and distributed systems, job scheduling,
performance optimization.
In this paper we investigate on a special type of job scheduler
for distributed heterogeneous systems called the switch and
feedback job scheduler. The main objective of the centralized
job scheduler is to achieve maximum performance with
reduced waiting time and faster response time for independent
tasks by reordering the processor queue list based on the
feedback received from each individual local processing
In distributed systems there is an increasing need for
efficient schedulers that could be used for managing a
distributed system. The distribution of independent tasks in a
heterogeneous network is a tedious job since it involves a
comparatively high complexity of different processors. It is
also vital to partition the program into tasks properly and then
queue the task into the job scheduler.
The main focus for many of the existing job schedulers is to
effectively distribute tasks and to achieve performance goals
such as minimizing communication, overhead, minimizing job
execution time, maximizing resource utilization, preserving
individual application performance so that jobs do not suffer
delays. Distributed computer systems have many advantages
such the capability to share processing of tasks in the event of
overloads and failure, transparently and modularity.
This paper presents a theoretical analysis based on the
results obtained from simulation. It should be noted that our
analysis does not include measurements of real systems.
However, we believe that the results we present are of practical
value. Although we do not derive absolute performance
predictions for specific systems and workloads, we studied the
relative performance across a broad range of architectures and
workloads and analyzed how changes in the system or
workload affect performance. In this paper, job tasks are
independent so they can execute at any time, in any order, and
at any processor.
1.1. Problem Identification
Load distribution is necessary in a distributed system for
better utilizing of its computational power. The scheduling
policies that currently exist are the static and adaptive policies.
Scheduling policies that use information from the system and
ignoring the current state are called static policies. Policies that
react to the system state are called adaptive policies. The
advantage of static policies is their simplicity. There are two
kinds of static policies: - deterministic policies and
probabilistic policies. Routing decision based on the system
state is called deterministic policies.
Job dispatcher chooses one of the processors based on the
outcome of an independent trials and this is called probabilistic
policies. Adaptive policies are complex since they receive
information about the current state of the system. In an
adaptive case jobs are assigned to one of the queues with equal
probability. When a processor becomes idle and there are jobs
waiting on the other queues in the network then the job is
A New Technique of Switch & Feedback Job Scheduling Mechanism in a
Distributed System
Syed Rizvi, Bevin Thomas and Khaled Elleithy
Computer Science and Engineering Department
University of Bridgeport
Bridgeport, CT 06601
{srizvi, bthomas, elleithy}
Tel: (203) 576-4703
Fax: (203) 576-4766
Aasia Riasat
Department of Computer Science
Institute of Business Management
Karachi, Pakistan 78100
Tel:92 (111) 002-004
Fax:92 (021) 509-0968
1-4244-1457-1/09/$25.00 © IEEE
This full text paper was peer reviewed at the direction of IEEE Communications Society subject matter experts for publication in the SpringSim 2009 proceeding.
Authorized licensed use limited to: University of Bridgeport. Restrictions apply.
transferred to the idle processor. The disadvantage of this
policy is to have a continuous communication between
processors in a network. In a distributed system, processors
will have to remain idle till it receives a job and thus causes
Parallel job scheduling has been studied widely in sections
particular to parallel and distributed systems. Dandamudi in [1]
conducted an intensive research of task scheduling in
multiprocessor systems. The result indicates scheduling
policies have a great impact on non-adaptive routing strategies.
Dandamudi also examined node scheduling policies on the
performance of sender-initiated and received-initiated dynamic
load sharing policies [2]. His simulation results reveal that the
SQFCFS policy performs better than the other methods
examined such as PrFCFS , PrLSTF, PrSTF.
Distributed algorithms such as sender initiated distributed
heuristic and receiver initiated distributed heuristics have been
studied and their performances were compared. If a system
needs help in running jobs then pick a machine in random and
then send a request to run its jobs and this is called sender
initiated distributed heuristic. If a system is idle it can pick a
machine in random and then send a request for more jobs to
processed. In [3], [4], [5], [6] the authors suggest parallel tasks
to start at essentially the same time, coordinate the execution
and compute at the same speed.
Switch and Feedback scheduling is a scheduler which
continuously interacts with the distributed system where each
processor follows a local policy. Switch and Feedback
scheduler reduces the waiting time for the job tasks over a
period of time. The main objective of this paper is to reduce
the waiting time for each heterogeneous distributed system
depending on local policies. The scheduler is called switch and
feedback scheduler.
The centralized scheduler consists of a processor queue, task
queue and the heterogeneous network as shown in Fig. 1.
Programs are partitioned into small job tasks and then queued
into the job scheduler based on First Come First Serve (FCFS).
The processor list queue is sorted based on the feedback
received from the local scheduler. The performance of the
execution improves over a period of time depending on the
Each local processor follows scheduling policies as
mentioned below:-
1) Send request from the processor for more tasks to the
centralized scheduler .The time required to send the request
depends on factors such as
a) Packet Latency time
b) Local processing time
c) Scheduler allocation processing time
d) Length of the processor and task queue
The benefit of this solution is reducing the waiting time for
each processor for the next task. In previous researches once
the processor executes the entire task it then it request for a
task in which a delay time is accounted for. In this case the
waiting time is reduced drastically.
3.1. Proposed Algorithm
The implementation of the proposed switch and feedback
mechanism based on the proposed algorithm is shown in Fig.
Figure 1
Fig1. An illustration of Switch and Feedback scheduler
Mean re-sequencing delay
Wait time for each packet used in processor
Processor utilization for processor
Current time in each processor
Queue processing time
The assumption processing time for processor
Total processing time for each task from the time
allocated by the central scheduler for processor
% of CPU usage given for processor
Look ahead time for processor
Number of task allocated for the processor i
Task request from processor I
FB Feedback from the processor
2. The following are some of the key steps that need to be
1. Invoke central job scheduler (C
) which controls the
allocation of task to each processor.
2. Invoke local scheduler (L
) which is a listener to
receive tasks allocated by the central job scheduler.
3. Send task request RQ
from each processor which
contains the idle processing speed, current load/cpu
usage, latency time.
4. Allocate a fixed number of task (n
) to each processor.
The initial number of task can vary depending on a set
of experimental iterations.
5. If more processor’s request is added then allocate
6. Send back request with feedback such as :-
a. Processing time of each task
b. Acknowledgement of the task
c. Current Usage
d. Wait time for the previous task
e. Total processing time of the task from the
time allocated by the central scheduler
7. Number of task allocated = maximum processing
taken by a processor / processing time by the current
processor to be allocated to) X processing time by the
current processor to be allocated to:
i =
( Max(T
) / T
) (1)
where i in (1) goes from 1 to n. For instance, if
processors P1, P2, P3 takes 2,5,10 as the execution
time for the initial task then the factor that depends on
the ratio of the maximum processing time to the
Fig2. Example showing the process of Switch and Feedback mechanism
processing time of the current processor to be
allocated to. In the case processor P1 the number of
allocation can be 5 times compared to that of the
processor P3 and therefore the number of task
allocated is 10, similarly in the case of processors P5,
P10 the number of allocation will be 2, 1 tasks
8. Calculate the look ahead time needed to send request
for more task to reduce the idle time. The Lookahead
time should be less than the processing time allocated
for that particular processor. This relationship is
shown in equations (2) and (3)
i =
( Max(T
) / T
) (2)
(X) T
Therefore the L
< T
and the next set of task should
be sent only if the processor has successfully agreed
on it.
9. Finally, sort the processor queue according to the
processing time taken for each cycle.
Each processor needs to send keep alive messages to
inform the central scheduler that the task is handled
appropriately. If the central scheduler doesn’t receive the
acknowledgement for the allocated task to that particular
processor , then the central scheduler understands that the task
has not be processed and therefore the task is reassigned to
that particular processor or any other processor.
The performance comparison was done between
Lookahead and regular job scheduler. Fig. 3 shows an
efficiency comparison with respect to the number of
processors. The efficiency linearly decreases as we increase
the number of processors in the system. The simulation was
based on random data which implies the time taken by each
job task for each processor. The program was done in C# and
the source code is presented below. In the simulation
program, 3 processors were used which sends request for job
to be allocated by the central job scheduler. Each job was
assigned at first based on first-come-first-serve. If the entire
process queue is empty then the scheduler has to wait for
more requests to be sent by the processors.
Before the processors completes the job task allocated to it
, a look ahead value was calculated based on the packet
latency time , central scheduler processing time , job
processing time by the processor. In the simulation, we have
taken a fraction before the job completes. The request is sent
to the central job scheduler and the process queue sorts the
requests based on the feedback received from the processor
which is the previous job execution time and thus the central
scheduler can resume its job.
The results are shown in Fig. 4 .It was noted that the
processing time was reduced and the waiting time by the
processor was reduced drastically. Thus it was concluded that
a proper Lookahead value can change the total processing
time and it depends on the packet latency time, central job
scheduler time, sorting time, job processing time by the
processor, CPU usage.
[1] S. Dandamudi, “Performance Implications of Task Routing and
Task Scheduling Strategies for Multiprocessor Systems”, In
Proceedings of the IEEE-Euromicro Conference on Massively
Parallel Computing Systems, IEEE Computer Society, Ischia,
Italy, May 2-6, 1994, pp. 348-353.
[2] S. Dandamudi, “The effect of Scheduling Discipline on Dynamic
Load Sharing in Heterogeneous Distributed Systems”, In
Proceedings of the 5th International Workshop on Modeling,
Analysis, and Simulation of Computer and Telecommunication
Figure 3
Fig3. Efficiency versus number of processors
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Not Sorted
Look Ahead
Fig4. Time versus number of jobs
Systems (MASCOTS ’97), IEEE Computer Society, Haifa,
Israel, January 12-15, 1997, pp. 17-24.
[3] H.D. Karatza, “A Simulation-based Performance Analysis of
Gang Scheduling in a Distributed System”, In Proceedings of
32nd Annual Simulation Symposium, IEEE Computer Society,
San Diego, CA, April 11-15, 1999, pp. 26-33.
[4] D. Talby, and D.G. Feitelson, “Supporting Priorities and
Improved Utilization of the IBM SP2 Scheduler using
Slackbased Backfilling”, In Proceedings of the 13th International
Parallel Processing Symposium and 10th Symposium on Parallel
and Distributed Processing, IEEE Computer Society, San Juan,
Puerto Rico, April 12-16, 1999, pp. 513-517.
[5] Y. Zhang, H. Franke, J. Moreira, and A. Sivasubramaniam, “The
Impact of Migration on Parallel Job Scheduling for Distributed
Systems”, In Proceedings of Europar, Europar, Munich,
Germany, 29 August to 2 September 2000, pp. 242-251.
[6] Y. Zhang, and A. Sivasubramaniam, Scheduling Besteffort and
Real-time Pipelined Applications on Time-shared Clusters”, In
Proceedings of the 13th Annual ACM Symposium on Parallel
Algorithms and Architectures, ACM, Crete Island, Greece, July 4
– 6, 2001, pp. 209-219.
ResearchGate has not been able to resolve any citations for this publication.
Conference Paper
Full-text available
Two important emerging trends are influencing the design, implementation and deployment of high performance parallel systems. The first is on the architectural end, where both economic and technological factors are compelling the use of off-the-shelf computing elements (workstations/PCs and networks) to put together high performance systems called clusters. The second is from the user community that is finding an increasing number of applications to benefit from such high performance systems. Apart from the scientific applications that have traditionally needed supercomputing power, a large number of graphics, visualization, database, web service and e-commerce applications have started using clusters because of their high processing and storage requirements. These applications have diverse characteristics and can place different Quality-of-Service (QoS) requirements on the underlying system (low response time, high throughput, high I/O demands, guaranteed response/throughput etc.). Further, clusters running such applications need to cater to potentially a large number of users (or other applications) in a time-shared manner. The underlying system needs to accommodate the requirements of each application, while ensuring that they do not interfere with each other.This paper focuses on the CPU resources of a cluster and investigates scheduling mechanisms to meet the responsiveness, throughput and guaranteed service requirements of different applications. Specifically, we propose and evaluate three different scheduling mechanisms. These mechanisms have been drawn from traditional solutions on parallel systems (gang scheduling and dynamic coscheduling), and have been extended to accommodate the new criteria under consideration. These mechanisms have been investigated using detailed simulation and workload models to show their pros and cons for different performance metrics.
Conference Paper
Full-text available
This paper evaluates the impact of task migration on gang-scheduling of parallel jobs for distributed systems. With migration, it is possible to move tasks of a job from their originally assigned set of nodes to another set of nodes, during execution of the job. This additional flexibility creates more opportunities for filling holes in the scheduling matrix. We conduct a simulation-based study of the effect of migration on average job slowdown and wait times for a large distributed system under a variety of loads. We find that migration can significantly improve these performance metrics over an important range of operating points. We also analyze the effect of the cost of migrating tasks on overall system performance.
Conference Paper
Distributed memory parallel systems such as the IBM SP2 execute jobs using variable partitioning. Scheduling jobs in FCFS order leads to severe fragmentation and uti- lization loss, which lead to the development of backlling scheudlers such as EASY. This paper presents a backlling scheduler that improves EAST in two ways: It supports both user selected and administrative priorities, and guarantees a bounded wait time for all jobs. The scheduler gives each waiting job a slack, which determines how long it may have to wait before running: 'important' and 'heavy' jobs will have little slack in comparison with others. Experimental results show that the priority scheduler reduces the average wait time by about 15% relative to EASY in an equal prior- ities scenario, and is responsive to differential priorities as well.
Conference Paper
In distributed systems job scheduling is a difficult problem. In this work we study a special type of scheduling called gang scheduling under which jobs consist of a number of interacting tasks which are scheduled to run simultaneously on distinct processors. The performance of various gang scheduling schemes is studied and compared for a variety of workloads. The main objective of the processor schedulers is to achieve high overall system throughput while at the same time providing some guarantee for the performance of individual jobs in the system
Conference Paper
Dynamic load sharing policies have been extensively studied. Most of the previous studies have assumed a homogeneous distributed system with a first-come/first-served (FCFS) node scheduling policy. In addition, job service times and inter-arrival times are assumed to be exponentially distributed. In this paper, we study the impact of these assumptions on the performance of sender-initiated and receiver-initiated dynamic load sharing policies in heterogeneous distributed systems. We consider two node scheduling policies-the FCFS and round-robin (RR) policies. Furthermore, the impact of variance in inter-arrival times and job service times is studied. Our results show that, even in heterogeneous distributed systems, when the RR policy is used, sender-initiated policy is better than the receiver-initiated policy unless the variance in job service times is low. This is an important observation, as most workstations use a scheduling policy that is similar to the RR policy considered in this paper
Conference Paper
In distributed task ready queue organizations, task routing refers to how ready tasks are assigned to processors in the system and task scheduling refers to how these tasks are scheduled on the assigned processor. In this paper, we consider the interaction between task routing and task scheduling strategies and their impact on the performance of the distributed task queue organization. We consider four task routing strategies two adaptive and two non-adaptive-and five task scheduling policies-two preemptive and three run-to-completion policies. We show that, when adaptive task routing is employed, the scheduling policy has only a marginal impact on performance and preemptive round robin policies tend to perform worse than the FCFS policy
Scheduling Besteffort and Real-time Pipelined Applications on Time-shared Clusters Figure 3 Fig3. Efficiency versus number of processors 0 20 40 60 80 100 120 140 160 12345678 9 10 11 12 13 14 15 16 17 18 19 20 Time(ns) Not Sorted Look Ahead Fig4 Time versus number of jobs
  • Y Zhang
  • A Sivasubramaniam
Y. Zhang, and A. Sivasubramaniam, “Scheduling Besteffort and Real-time Pipelined Applications on Time-shared Clusters”, In Proceedings of the 13th Annual ACM Symposium on Parallel Algorithms and Architectures, ACM, Crete Island, Greece, July 4 – 6, 2001, pp. 209-219. Figure 3 Fig3. Efficiency versus number of processors 0 20 40 60 80 100 120 140 160 12345678 9 10 11 12 13 14 15 16 17 18 19 20 Time(ns) Not Sorted Look Ahead Fig4. Time versus number of jobs