On Intelligent Mitigation of Process Starvation In Multilevel Feedback Queue Scheduling

CPU time-share process schedulers for computer operating systems have existed since Corbato published his paper on the Compatible Time Sharing System in 1962 [8]. With this new type of scheduler came the need to effectively divide CPU time between N processes, where N could be 2 or more processes. Modern time-sharing process schedulers which have been developed in the decades since have been designed to favor shorter, interactive processes over long-running processes, especially when incoming demand for CPU time exceeds supply and process starvation is inevitable. These schedulers, including Linux CFS, FreeBSD Ule, and the Solaris Fair Share Scheduler, are all effective at favoring interactive processes under starvation conditions. Sometimes it’s not desirable that long-running processes be sacrificed altogether, but none of these schedulers have safeguards under starvation conditions. This thesis revisits and extends the research conducted in [13], in which it was demonstrated that starvation of long-running processes could be safely and effectively mitigated without adversely affecting the performance of shorter, interactive processes. The questions this thesis will answer are: Can MLFQ-NS, proposed in [13], be compared to other modern process schedulers? Can MLFQ-NS be improved? To answer the first question, a scheduler must be found which is similar enough to MFLQ for a direct comparison. This will require a survey of current schedulers. To answer the second question, the research conducted in [13] must be duplicated MLFQ-NS to ascertain the following: How much diverted time is actually used? Why does MLFQ-NS become ineffective past a certain system-load threshold, i.e. stop real- locating time to long-runnning processes? In this research, the original work was duplicated in simulations to validate previous re- sults, and determine why MLFQ-NS became ineffective after incoming CPU time demand exceeds a threshold. Research was conducted in order to determine if starvation mitigation in MLFQ-NS could be compared to other process schedulers used in production, with the conclusion that recent emphasis on priority scheduling and heurstic interactivity determination makes such a comparison impossible. Research then continued with simulations in which MLFQ-NS was given different run- time arguments than original simulations. Investigations into those results led to an algorithmic modification to MLFQ-NS called MLFQ-IM and analysis of simulations of MLFQ-IM. Conclu- sions about the effectiveness of MLFQ-IM will be explored. Finally, ideas for future research are offered

Assessment of Response Time for New Multi Level Feedback Queue Scheduler

Response time is one of the characteristics of scheduler, happens to be a prominent attribute of any CPU scheduling algorithm. The proposed New Multi Level Feedback Queue [NMLFQ] Scheduler is compared with dynamic, real time, Dependent Activity Scheduling Algorithm (DASA) and Lockes Best Effort Scheduling Algorithm (LBESA). We abbreviated beneficial result of NMLFQ scheduler in comparison with dynamic best effort schedulers with respect to response time.Comment: 7 pages, 5 figure

Designing of vague logic based multilevel feedback queue scheduler

AbstractMultilevel feedback queue scheduler suffers from major issues of scheduling such as starvation for long tasks, fixed number of queues, and static length of time quantum in each queue. These factors directly affect the performance of the scheduler. At many times impreciseness exists in attributes of tasks which make the performance even worse. In this paper, our intent is to improve the performance by providing a solution to these issues. We design a multilevel feedback queue scheduler using a vague set which we call as VMLFQ scheduler. VMLFQ scheduler intelligently handles the impreciseness and defines the optimum number of queues as well as the optimal size of time quantum for each queue. It also resolves the problem of starvation. This paper simulates and analyzes the performance of VMLFQ scheduler with the other multilevel feedback queue techniques using MatLab

Workload Schedulers - Genesis, Algorithms and Comparisons

In this article we provide brief descriptions of three classes of schedulers: Operating Systems Process Schedulers, Cluster Systems, Jobs Schedulers and Big Data Schedulers. We describe their evolution from early adoptions to modern implementations, considering both the use and features of algorithms. In summary, we discuss differences between all presented classes of schedulers and discuss their chronological development. In conclusion, we highlight similarities in the focus of scheduling strategies design, applicable to both local and distributed systems

Predicting software performance in symmetric multi-core and multiprocessor Environments

With today\u27s rise of multi-core processors, concurrency becomes a ubiquitous challenge in software development.Performance prediction methods have to reflect the influence of multiprocessing environments on software performance in order to help software architects to find potential performance problems during early development phases. In this thesis, we address the influence of the operating system scheduler on software performance in symmetric multiprocessing environments

The Battle of the Schedulers: FreeBSD ULE vs. Linux CFS

This paper analyzes the impact on application performance of the design and implementation choices made in two widely used open-source schedulers: ULE, the default FreeBSD scheduler, and CFS, the default Linux scheduler. We compare ULE and CFS in otherwise identical circumstances. We have ported ULE to Linux, and use it to schedule all threads that are normally scheduled by CFS. We compare the performance of a large suite of applications on the modified kernel running ULE and on the standard Linux kernel running CFS. The observed performance differences are solely the result of scheduling decisions, and do not reflect differences in other subsystems between FreeBSD and Linux. There is no overall winner. On many workloads the two schedulers perform similarly, but for some workloads there are significant and even surprising differences. ULE may cause starvation, even when executing a single application with identical threads, but this starvation may actually lead to better application performance for some workloads. The more complex load balancing mechanism of CFS reacts more quickly to workload changes, but ULE achieves better load balance in the long run

The Battle of the Schedulers: FreeBSD ULE vs. Linux CFS

International audienceThis paper analyzes the impact on application performance of the design and implementation choices made in two widely used open-source schedulers: ULE, the default FreeBSD scheduler, and CFS, the default Linux scheduler. We compare ULE and CFS in otherwise identical circumstances. We have ported ULE to Linux, and use it to schedule all threads that are normally scheduled by CFS. We compare the performance of a large suite of applications on the modified kernel running ULE and on the standard Linux kernel running CFS. The observed performance differences are solely the result of scheduling decisions, and do not reflect differences in other subsystems between FreeBSD and Linux. There is no overall winner. On many workloads the two schedulers perform similarly, but for some work-loads there are significant and even surprising differences. ULE may cause starvation, even when executing a single application with identical threads, but this starvation may actually lead to better application performance for some workloads. The more complex load balancing mechanism of CFS reacts more quickly to work-load changes, but ULE achieves better load balance in the long run

Automatic User Interaction Detection and Scheduling with RSIO

Response time is one of the most important factors for the overall usability of a computer system. We present RSIO, a processor scheduling framework for improving the response time of latency-sensitive applications by monitoring accesses to I/O channels and inferring when user interactions occur. RSIO provides a general mechanism for all user interactions, including direct interactions via local HCI devices such as mouse and keyboard, indirect interactions through middleware, and remote interactions through networks. It automatically and dynamically identifies processes involved in a user interaction and boosts their priorities at the time the interaction occurs to improve system response time. RSIO detects processes that directly handle a user interaction as well as those indirectly involved in processing the interaction, automatically accounting for dependencies and boosting their priorities accordingly. RSIO works with existing schedulers, processes that may mix interactive and batch activities, and requires no application modifications to identify periods of latency-sensitive application activity. We have implemented RSIO in Linux and measured its effectiveness on microbenchmarks and real applications. Our results show that RSIO is easy to use and can provide substantial improvements in system performance for latency-sensitive applications