KR20010103719A - Method and apparatus for providing operating system scheduling operations - Google Patents

Abstract

In a computer-implemented method and apparatus for scheduling threads included in a thread list, at least two threads have priority to indicate scheduled execution for both threads. The present invention is directed to modifying scheduled execution of at least two threads of equal priority during traversal across a thread list, performing deadline processing on at least one thread, and at least one predetermined error condition for the thread. Follow the steps to investigate.

Description

METHOD AND APPARATUS FOR PROVIDING OPERATING SYSTEM SCHEDULING OPERATIONS}

Set-top box television environments are real-time environments where operations must be performed quickly. In a set top box environment, a computer implemented thread runs on a central processing unit (CPU) to perform many functions for a set top box, such as but not limited to providing video and audio to a user. In such an environment, threads must be scheduled to optimize the time required for their functionality to be achieved.

FIELD OF THE INVENTION The present invention relates generally to television set-top boxes and, more particularly, to computer implemented kernel operation in set top box television environments.

1 is a perspective view of a set top box system.

FIG. 2 is a block diagram illustrating various example programs within the set top box system of FIG. 1.

3 is a block diagram illustrating a new three-layer scheduling system of the present invention.

4 is a block diagram illustrating processing of a thread list in a single pass.

5 is a flow diagram illustrating the operational steps for a thread when forming a single pass across a thread list.

The present invention addresses this need and other needs of a set top box environment. According to the teachings of the present invention, there is provided a computer-implemented method and apparatus for scheduling threads included in a thread list. At least two threads have priority to indicate scheduled execution for both threads. The present invention is directed to modifying scheduled execution of at least two threads having equal priority among the transitives in the thread list, performing deadline processing for at least one thread, and for a predetermined error condition of at least one thread. Provide steps for investigation.

1 shows an exemplary set-top box 20 connected to a television 24 via a cable 28. A cable 32 provides broadcast analog, broadcast digital, and interactive digital transmission to the set top box 20. The set top box 20 includes application and operating system software for providing an advanced interactive television environment. The operating system is used by the set top box 20 to provide an interface between the various applications and the application software used, for example, by the set top box 20.

2 shows the software components of the set top box. The set-top box's multitasking operating system addresses the high performance demands of media-centric real-time applications delivered through set-top boxes. The operating system provides an open, scalable platform for developing multimedia content and delivering it to consumers via broadcast and client / server networks. The software architecture for the operating system includes layers of interconnected modules to minimize redundancy and optimize multimedia processing in the interactive network setup. The layer of structure includes a hardware abstraction layer 40, a core layer 42, an application support layer 44 and an application layer 46.

Each hardware device associated with the multimedia client is abstracted into a software device module mounted on the hardware abstraction layer 40. Each of these device modules is responsible for the media delivery and operation between the hardware device and the rest of the operating system. Application program interfaces (APIs) supported by each device module cover the characteristics of different hardware implementations, with the portable operating system facilities separate from each device's hardware dependencies.

The kernel 48 and the memory manager 50 mounted on the core layer 42 provide basic functions necessary to support an application program. The fully preemptive multithreaded multitasking kernel is designed to optimize set-top box memory footprint and processing speed. Since the operating system is mounted on the consumer unit, it is designed to exist in a ROM based system with a very small footprint (eg 1 megabyte). The kernel is also created to use a 32-bit Reduced Instruction Set Computer (RISC) processor capable of high-speed transfer, manipulation and display of complex media types.

Within the field of the present invention, a process is a subject that owns the system resources assigned to the process. A thread is a unit of string of work or instructions to be executed. A process can have more than one thread, which is considered "multithreaded".

The memory manager 50 provides an efficient allocation technique that can achieve the best performance by using limited memory resources. The memory manager 50 provides an efficient memory allocation technique that can achieve optimal performance using limited set-top memory resources. Core layer 42 provides a standard set of integrated event system 52 and ANSI C utility functions. The application support layer 44 is mounted on the core layer 42. This set of support modules provides a higher level of processing and application services.

Application management, session management, and tuner management are some examples of these services. At the highest application level 46, at least one application, referred to as a resident program, is typically running in a set top box at all times. Application level 46 also provides the necessary capacity to describe the application and to manage resources (e.g., tuners) between resident applications mounted on the set-top box and other background applications.

3 illustrates a three-tiered structured scheduling operating system used by operating system scheduler 100. In the lower layer 102, a round robin scheduler 104 is used for threads that share an equal priority level. For example, if there are three threads at priority 5 and all threads are waiting, each thread is given a short time slice in sequence. This "soft real time" approach is advantageous in that individually written multithreaded applications run on the same system without knowing each other.

The intermediate layer 106 is a preemptive scheduler 108. In the preemptive lien schedule 108, the priority level cannot be reversed. For example, if both priority 3 and priority 4 threads are waiting to be executed, priority 3 threads will run. This scheduling scheme includes the benefit of prioritizing the deadline of the most critical waiting thread. Preemptive lien scheduling is commonly used in "hard" real-time systems, which can be very costly if missed deadlines.

The upper layer 110 allows applications and drivers to implement the customer scheduling algorithm 112 using a call that allows the thread to vary to its own priority or other priority level. Priority change schemes include, but are not limited to, the following schemes, priority inheritance, and priority inversion.

In priority inheritance, a thread inherits the priority of a more deterministic thread that will be waiting for resources occupied by a less deterministic thread. Another type of priority inheritance allows the monitor thread to provide services to other threads while inheriting the priority of the client's threads on a per request basis.

In priority inversion, the priority priority is simply reversed (ie, high priority becomes low priority) so that less critical threads can run long enough to release resources requested by more critical threads. This is typically triggered when a high priority thread detects that it needs a resource occupied by a low priority thread that is not given any execution time at all because of a third thread with medium priority.

The present invention includes other customer scheduling methods that may be used, for example, rate monotonic scheduling, leased space slack-time scheduling, and earliest deadline scheduling. .

4 illustrates components and operations associated with thread list 130 transverse in one pass 134. The present invention preferably provides a thread list traverser for performing multiple scheduling operations within one pass 134, such as round robin scheduling 104, due date processing 138, and error checking 142. 138) traverse the list of threads in one pass.

Within the preemptive kernel 146, threads of the same priority as well as threads of other priorities attempt to obtain a time slice of processing. Preferably, the present invention is not limited to this, for example, a user may press a key at any time, and a thread is currently running to service a pressed key event whatever was running in the set-top box. Use a fully propagated kernel that interrupts any thread to indicate that it can run.

Round robin scheduling 104 is efficiently performed by rotating the priority of threads having the same priority within one pass 134. Priority rotation 150 preferably uses bubble sorting 154 to rotate threads of the same priority in one pass 134. The term "one pass" in the present invention preferably means that the top of the list is not considered and the traversal to the previous thread in the list is minimized.

Priority rotation 150 internally resets threads of the same priority to be rotated. For example, but not limited to, four threads of all priority levels 9 may operate. Priority rotation scheme 150 internally sets the priority levels of the threads to 9.1, 9.2, 9.3, and 9.4. However, for each pass, the priority levels are switched by way of bubble sorting 154 with priority levels 9.1, 9.2, 9.3 and 9.4. The rotation has the effect of bringing the thread at the bottom (ie priority level 9.4) to priority level 9.1. A thread that was at priority level 9.1 is at priority level 9.2, and so on for the other two threads in this example.

If the top thread has nothing to process and there is a thread at the second position, the thread at the second position will run until the top thread has to do within its time slice. Within one pass 134, the deadline process 138 performs a timeout check to check for threads 162 whose timeout 166 has expired. Thread 162 includes a timeout value 146 in the data structure indicating the time that the thread should wait for thread list 130 for the event. The thread list traversal 138 checks in one pass 134 if the thread's timeout value has been reached. Once the timeout value 166 has been reached, the thread traversal machine "wakes up" the thread so that the thread can perform appropriate processing for the timeout.

The invention can be scheduled to occur at a future time after an event is defined. The time thereafter may be defined in very precise units of time, such as but not limited to, for example, billionths of a second. This is typically used for time critical applications.

However, in other situations this solution is more precise than what is actually needed. Sometimes, a solution measuring in hundredths of seconds is sufficient. Thus, the present invention allows each thread to have a coarse time-out 180 or a fine time-out 184. One non-limiting advantage of the schematic timeout is that it is implemented very efficiently and typically uses less central processing unit (CPU) cycles to support it. This efficient implementation uses a scheduler that is configured to form a single pass 134 via thread list 130 for scheduler interrupts that are issued every 10 milliseconds. While thread list 130 is traversed, timeout check 158 may be performed to check for expired timeout 166 as a single compare operation.

Also within the illustrative context, there are typically about 25 operating system threads running on set top boxes in addition to application threads. At any time, most of this thread is in event waiting mode. The use of the coarse timeout in an event waiting situation ensures that the timer queue 129 (which processes the event) is not too "crowded".

The scheduler 100 preferably forms a single pass 134 once every 10 milliseconds across the thread list. While this pass over the thread list is performed, the scheduler 100 also performs error checking for error conditions such as, but not limited to, stack overflow and stack underflow.

Each of the threads 162 has a priority level 190. Thread 162 may preferably assume a priority level in the 1-31 range. There can be any number of threads and multiple threads sharing the same priority level. In the preferred embodiment, the most critical priority level is 1 and the least critical priority level is 31.

The present invention preferably includes a predetermined number of predetermined threads 194 where at least one thread always remains at the top of the thread list 130 and at least one thread remains at the bottom of the thread list 130. In this preferred embodiment, the present invention includes a system thread 198 with the highest priority and an idle thread 202 with the lowest priority. System threads 198 use priority level 0 and idle threads 202 use priority level 32, which is the priority level allowed for drivers and applications from priority level 1 to priority. It is outside the range because it is in the level 31 range.

It is to be understood that the present invention is not limited to the disclosed level of priority techniques, but includes all priority techniques appropriate for a given situation.

Since thread list 130 is sorted by thread priority, system thread 198 is always the first subject and idle thread 202 is always the last subject. This means that the scheduler 100 managing the thread list 130 takes no account of the special case of adding new threads to the beginning or end of the list.

The invention also includes a scheduler thread 206 having a second highest priority that is second to the priority level of the system thread 198. Due to the use of predetermined threads, the present invention does not need to examine the absence of the final pointer at the end, since only a survey of idle threads indicates when to stop examining the list.

The present invention schedules the event to occur at a " forever " time, which is the furthest time that can expire in the preferred embodiment. This event may not occur at all and will always be present at the end of the time queue (sorted by event time). This means that the present invention does not consider any negotiation with an empty timer queue or adding an event to the end of the list.

5 is a flow diagram illustrating exemplary operational steps performed by the scheduler to form one pass through a thread list. Start mark block 250 indicates that iteration block 254 is executed first. At repeat block 254, a single pass is formed over the thread list. In iteration block 258, certain steps are performed for each thread.

Processing block 262 compares the priority level of the currently selected thread with the priority of the previous thread. If the threads do not have the same priority as determined by decision block 266, then processing block 274 is executed. However, if the threads are of the same priority, then the round robin scheduling scheme of the present invention is used in processing block 270 so that the threads are preferably bubble sorted and the execution order is reversed for threads having the same priority. Processing continues at processing block 274.

At processing block 274, a check is made to determine if the thread currently being analyzed by the scheduler has timed out. If so, the thread wakes up so that the thread can perform a timeout operation. Processing block 278 is executed to perform error checking.

Decision block 282 queries whether the idle thread with the lowest priority is considered. If so, processing block 264 is processed and a predetermined time must expire before repeating block 254 is executed. If decision block 282 does not find the idle thread that was considered, then iteration block 258 is executed.

The foregoing embodiments of the invention have been described for purposes of illustration and are not intended to limit the invention. Those skilled in the art should appreciate that various changes and modifications can be made to the embodiments discussed herein without departing from the spirit and scope of the invention as defined by the appended claims. For example, the present invention includes that the process shown in FIG. 5 also includes the use of the other layer scheduling scheme of FIG.

Claims (20)

A computer implemented method for scheduling threads included in a thread list, wherein at least two threads have a priority indicative of scheduled execution for those two threads. During the traversal of the thread list (a) modifying scheduled execution of at least two threads of equal priority; (b) performing deadline processing on at least one of the threads; (c) examining a predetermined error condition for at least one of the threads. How to include. 2. The method of claim 1, further comprising performing bubble sort during the traversal to modify scheduled execution of the at least two threads having equal priority. 2. The method of claim 1, wherein at least one of the threads comprises a time-out value, and further comprising examining the timeout value during the traversal to determine if a deadline associated with the thread has occurred. How to. 2. The method of claim 1, wherein at least one of the threads comprises a coarse time-out value and examining the coarse timeout value during the traversal to determine if a deadline associated with the thread has occurred. How to include more. The method of claim 1, wherein the first thread comprises a coarse time-out value and the second thread comprises a fine time-out value, Examining the coarse timeout value of the first thread during the traversal to determine if a deadline associated with the first thread has occurred; Examining the precision timeout value of the second thread during the traversal to determine if a deadline associated with the second thread has occurred. How to include more. 2. The method of claim 1, further comprising maintaining a thread in the thread list scheduled for first execution within the thread list during each traversal of the thread list. The method of claim 1, further comprising maintaining a thread in the thread list that is scheduled to run last in the thread list during each traversal of the thread list. 8. The method of claim 7, further comprising performing another traversal of the thread list after determining the thread to be executed last in the thread list. 8. The method of claim 7, further comprising maintaining a thread in the thread list that is scheduled to run substantially first in the thread list during each traversal of the thread list. 2. The method of claim 1, wherein setting the priority of the first thread to be the highest priority in the thread list such that the first thread is scheduled to run substantially within the thread list during each traversal of the thread list. How to include more. 11. The method of claim 10, wherein the priority of the second thread is set to be the lowest priority in the thread list such that a second thread is scheduled to run substantially within the thread list during each traversal of the thread list. The method further comprises a step. 12. The method of claim 11, wherein the priority of the second thread is to be the second highest priority in the thread list such that the third thread is scheduled to execute substantially second in the thread list during each traversal of the thread list. The method further comprises the step of setting. The method of claim 12, Using the first thread to perform a system operation; Using the second thread to perform a scheduling operation; Using the third thread as an idle thread. 2. The method of claim 1, further comprising investigating a stack error condition associated with one of the threads during the traversal. A computer implemented apparatus for scheduling a thread, wherein at least two threads of the thread have a priority indicative of scheduled execution of these two threads. A thread list containing the thread, During a single traversal of the thread list (a) modifying scheduled execution of at least two threads of equal priority; (b) performing a deadline process on at least one of said threads, (c) a thread list traverser performing the step of examining a predetermined error condition for at least one of the threads. Device comprising a. 16. The apparatus of claim 15, wherein the thread list traversal performs bubble sorting during the traversal to modify the scheduled execution of at least two threads of equal priority. 16. The apparatus of claim 15, wherein at least one of the threads comprises a timeout value and the thread list traversal examines the timeout value during the traversal to determine if a deadline associated with the thread has occurred. 16. The apparatus of claim 15, wherein at least one of the threads comprises a coarse timeout value, and wherein the thread list traversal device examines the coarse timeout value during the traversal to determine if a deadline associated with the thread has occurred. . 16. The system of claim 15, wherein the first thread includes a coarse timeout value and the second thread includes a precise timeout value, wherein the thread list traversal unit is configured to determine whether a deadline associated with the first thread has occurred. The coarse timeout value of one thread is examined during the traversal, and the thread list traversal unit reads the fine timeout value of the second thread during the traversal to determine whether a deadline associated with the second thread has occurred. Device to investigate. 16. The method of claim 15, further comprising: a first thread that is substantially permanently present in the thread list and that executes first in the thread list; A second thread that is substantially permanently present in the thread list and finally runs within the thread list, And the thread list traversal machine performs another traversal of the thread list after determining the second thread during the traversal.