• The Transactions of the Korea Information Processing Society
• /
• v.6 no.11
• /
• pp.3131-3139
• /
• 1999

Satisfying the rigid timing requirements of various real-time activities in real-time systems often requires some special methods to tune the systems run-time behaviors. Unbounded blocking can be caused when a high priority activity cannot preempt a low priority activity. In such situation, it is said that a priority inversion has occurred. The priority inversion is one of the problems which may prevent threads from meeting the deadlines in the real-time systems. It is difficult to remove such priority inversion problems in the kernel at the same time to bound the worst case blocking time for the threads. A thread is a piece of executable code which has access to data and stack. In this paper, a new real-time systems. It is difficult to remove such priority inversion problems in the kernel at the same time to bound the worst case blocking time for the threads. A threads is a piece of executable code which has access to data and stack. In this paper, a new real-time server model, which minimizes the duration of priority inversion, is proposed to reduce the priority inversion problem. The proposed server model provides a framework for building a better server structure, which can not only minimize the duration of the priority inversion, but also reduce the deadline miss ratio of higher priority threads.

• The KIPS Transactions:PartA
• /
• v.13A no.5 s.102
• /
• pp.405-412
• /
• 2006

Real-time operating systems have been used in various computing environments, where a job must be completed in its deadline, with various conditions, such as effective scheduling policies, the minimum of an interrupt delay, and the solutions of priority inversion problems, that should be perfectly satisfied to design and develop optimal real-time operating systems. Up to now, in order to solve priority inversion problems among several those conditions. There have been two representative protocols: basic priority inheritance protocol and priority ceiling emulation protocol. However, these protocols cannot solve complicated priority inversion problems. In this paper, we design a protocol, called recursive priority inheritance (RPI), protocol that effectively solves the complicated priority inversion problems. Our proposed protocol is also implemented in the Linux kernel and is compared with other existing protocols in the aspect of qualitative analysis.

• The KIPS Transactions:PartA
• /
• v.16A no.6
• /
• pp.463-472
• /
• 2009

Real-time operating systems must have satisfying various conditions such as effective scheduling policies, minimized interrupt delay, resolved priority inversion problems, and its applications to be completed within desired deadline. The real-time operating systems, therefore, should be designed and developed to be optimal for these requirements. MicroC/OS-II, a kind of Real-time operating systems, uses the basic priority inheritance with a mutex to solve priority inversion problems. For the implementation of mutex, the kernel in an operating system should provide supports for numerous tasks with same priority. However, MicroC/OS-II does not provide this support for the numerous tasks of same priority. To solve this problem, MicroC/OS-II cannot but using priority reservation, which leads to the waste of unnecessary resources. In this study, we have dealt with new design a protocol, so called TPSP(Temporary Priority Swap Protocol), by an effective solution for above-mentioned problem, eventually enabling embedded systems with constrained resources environments to run applications.

• Journal of the Institute of Electronics Engineers of Korea CI
• /
• v.39 no.6
• /
• pp.36-46
• /
• 2002

This paper proposes an integrated scheduling mechanism for embedded system with real-time web server to meet the characteristics of real time task. The proposed scheduling mechanism may solve the so-called priority inversion problem in scheduling between urgent web requests and tasks with low priorities. The priority inversion problem happens because of operating two independent schedulers, web scheduler and operating system scheduler in a system without considering the requirements of each other. In the proposed mechanism, two schedulers are integrated in an operating system and the integrated scheduler schedules tasks for urgent web requests with real time characteristics and other application tasks together. Since all tasks are scheduled by one unified scheduler that knows the characteristics of tasks, the tasks are scheduled with their absolute priorities and thus the priority inversion problem can be eliminated. The performance is measured on a prototype embedded system with the proposed algorithm.

• The Transactions of the Korea Information Processing Society
• /
• v.6 no.12
• /
• pp.3652-3661
• /
• 1999

To support multimedia applications such as a multimedia communication systems and multimedia broadcasting, an operating system need to predict their timing-constraints. So, In this real-time systems, we must solve the priority inversion problem that may make the behavior of unpredictable systems and need a real-time server model that provides a better preemptability and minimizes a system overhead. In current real-time systems, the single thread server model, the worker model and the dynamic server model are being used for synchronization but they cannot propose an effective structure for managing shared resources. In this paper, the priority inheritance protocol is used to solve the priority inversion problem and the hybrid prioritized worker model is proposed, which can provide a more effective structure and a faster response time minimizing a system overhead. The hybrid prioritized worker model is to combine the static and the dynamic prioritized worker model, and have a better performance than other models in response time which is an important factor in a real-time system.

• The KIPS Transactions:PartA
• /
• v.16A no.3
• /
• pp.189-198
• /
• 2009

The traditional interrupt-based protocol processing at end hosts has two priority-inversion problems. First, low-priority packets may interrupt and delay high-priority process executionssince interrupts have the highest priority in most operating systems. Second, low-priority packet may delay high priority packets when they arrive almost simultaneously since interrupt processing is performed in a FCFS (first come, first served) order. These problems can be solved by a priority-based protocol processing policy and implementation. However, general priority-based schemes commonly have the problem of starvation and cannot support the each network flow requiring the mutually exclusive QoS since the packets are processed in the FCFS order. Therefore, the priority-based schemes are not appropriate for different QoS-demanding applications. In this paper, we present a bottom-half-based approach that relies on priority- and budget-based processing. The proposed approach allows us to solve both the starvation and priority-inversion problems, and further enables effective QoS isolation between different network connections. This feature also enables bounding the protocol processing time at an end host. We finally show through experiments that the proposed approach achieves QoS isolation and control.

• The Journal of Korean Institute of Communications and Information Sciences
• /
• v.26 no.7A
• /
• pp.1170-1181
• /
• 2001

본 논문은 다양한 실시간 스케줄링 알고리즘과 자원 접근 제어 정책을 통합적으로 설계/구현하되 필요에 따라 시스템을 선택적으로 재구성할 수 있게 하는 통합 실시간 스케줄링 모델을 제안한다. 제안 모델은 [3, 4]에서 제안된 기존 모델에 자원 관리자 및 대기 큐 관리자가 추가되었다. 사용자는 태스크 및 자원 속성을 기반 스케줄링 알고리즘에 상관없이 동일하게 지정할 수 있다. 반면 시스템 설계자는 우선순위 역전 문제를 해결하고 공유 자원에 대한 한정된 블록킹 시간을 보장하기 위한 다양한 자원 접근 제어 정책들을 하위 단계의 복잡한 커널 모듈을 수정하지 않고도 효율적으로 개발할 수 있다. Real-Time Linux [6]에 제안된 스케줄러 모델을 구현한 후, 이를 기반으로 다양한 스케줄링 알고리즘과 자원 접근 제어 정책들을 시험적으로 구현하여 보았다. 여러 성능 실험을 통해 제안 모델을 기반으로 다양한 알고리즘과 정책을 구현한다 해도 실행시의 오버헤드는 크지 않은 반면, 시스템 재구성과 자원 접근 제어 정책을 효과적으로 지원할 수 있다는 것을 확인할 수 있었다.

• Journal of KIISE:Computer Systems and Theory
• /
• v.30 no.2
• /
• pp.68-77
• /
• 2003

The Least-Laxity First(or LLF) scheduling algorithm assigns the highest priority to a task with the least laxity, and has been proved to be optimal for a uni-processor and sub-optimal for a multi-processor. However, this algorithm Is Impractical to implement because laxity tie results in the frequent context switches among tasks. In this paper, a Modified Least-Laxity First on Multiprocessor(or MLLF/MP) scheduling algorithm is proposed to solve this problem, i.e., laxity tie results in the excessive scheduling overheads. The MLLF/MP is based on the LLF, but allows the laxity inversion. MLLF/MP continues executing the current running task as far as other tasks do not miss their deadlines. Consequently, it avoids the frequent context switches. We prove that the MLLF/MP is also sub-optimal in multiprocessor systems. By simulation results, we show that the MLLF/MP has less scheduling overheads than LLF.