CN100576175C - The parallel executing method and the system that are used for a plurality of kernels - Google Patents

Abstract

The invention discloses a kind of parallel executing method and system that is used for a plurality of kernels.Providing a kind of is used to use common interrupt processor and optional common scheduler to move the method for a plurality of kernels concurrently.The technology of between described a plurality of kernels execution being switched also is provided.Show and use the execution and the interruption between described a plurality of kernels of interrupt mask level to take the lead.The technology that is used for shared resource between moving on the different kernels of task also is provided.

Description

The parallel executing method and the system that are used for a plurality of kernels

Technical field

The present invention relates generally to multiple task operating system.More particularly, the present invention relates to carry out a plurality of kernels with permission, thereby in single operating, support the feature of a plurality of kernels by use common interrupt processor and common scheduler.

Background technology

Usually based on the special applications of using operating system, operating system is designed, and its operation is optimized.Usually expect that this operating system has one type operating system available feature in another operating system.

For example, has a stack features widely such as the common computer operations system of Linux and Windows, such as file system, device driver, application program, storehouse etc.Such operating system allows the executed in parallel of a plurality of programs, and attempts to optimize the response time (being also referred to as the stand-by period) that is associated with the service of executive routine concurrently and CPU uses or load.Yet unfortunately, such operating system is not suitable for Embedded Real-Time usually and uses; For example, such as the control of robot, telecommunication system, lathe, automotive system etc.Such as these and many other so-called hard real-time performances of the application need based on real world, incident and control.The hard real-time performance has guaranteed the worst case response time.The general-purpose operating system (GPOS) has been traded off usually at the predictability of the program execution time of the average behavior of application program.Comprise iTRON ^TMDeng several known real time operating system (RTOS) the hard real-time feature is provided.Yet regrettably, most of RTOS do not have many GPOS features, and, the support to different file system, device driver, application library etc. for example is not provided.In many application, expectation has the performance of RTOS and the feature of the general-purpose operating system.

For example, Linux is the known general-purpose operating system, has the desired many features of modern comfort that comprise modern operating system feature, a large amount of developing instrument, networking etc.Yet, Linux is not designed to embedded OS.Such as and be not limited to many modern comforts of set-top box, mobile phone and auto-navigation system, not only need be, and need as the feature of the embedded OS of performance in real time such as the feature of the general-purpose operating system of Linux.

For example, iTRON is the real-time embedded operating system that generally is used in the maturation in a large amount of embedded devices.ITRON has the desired many features of embedded device, but it lacks such as networking, to the feature of the Linux of the support of different file etc.

It to GPOS and the two example that all needs of RTOS the controller of the navigational system in automobile, used.This controller is from position and the direction of GPS sensor readings to calculate this automobile.Based on current location, destination and the topological map that extracts from navigation data DVD, this controller compute best paths also shows on the LCD screen.Can cover LCD screen with touch pad, be used for navigation system input parameter.The task of the task of read transducer, touch pad input needs hard real-time; The task of calculating path, the task of display graphics, reading from DVD of task are the standard program tasks, and use the feature of the general-purpose operating system.Can realize the hard real-time performance such as the RTOS kernel of iTRON by using, and can on linux kernel, move common tasks simultaneously.

GPOS and the two another example that all needs of RTOS are to use the controller of the solid-state digital video camera of video data compression hardware.In such application, data stream and carries out image processing function from compression hardware are read in expectation, demonstration and store data on movable storage medium on LCD screen simultaneously.Also may for example must use same control system to manage optical zoom mechanic and automatic focusing mechanism.If system uses some legacy devices, then may there be (for example, iTRON) available Control Software widely at specific RTOS.Can come the task of task, data aggregation and the storage of processing controls motor well by hard real-time operating system (hRTOS), and can manage demonstration, Flame Image Process and other functions better by common standard program under GPOS simultaneously.In addition, will be in iTRON available software transplanting widely is normally very high to the cost of another RTOS, and provides in iTRON and show and file system support etc. may be remarkable equally.Therefore, in this example, use for this, the system that the characteristics of the characteristics of RTOS and the general-purpose operating system are combined will be best.

To GPOS and the two another example that all needs of RTOS is for specific function being quickened or additional particular functionality and needs use in the system of specialized hardware.For example, in many multimedia equipments, must use graphics accelerator chip or be used for the DSP or the CODEC of audio or video.In some cases, if operating system can provide guaranteed performance for some tasks, then can remove needs to additional firmware.For example, in the system that supports streaming audio, possibility must have assurance and with definite speed the audio frequency with coding of compression be decoded to avoid the high-performance task of the definite output quality of packet loss and maintenance.In some cases, comprise the possible needs that can remove specialized hardware of system of GPOS and RTOS, reduced cost of products thus.

All real world systems can be categorized as hard real-time (HRT) system, soft (SRT) system or non real-time (NRT) system in real time.Hard real-time system is such system, that is, in this system, final term or timing constraint must be never missed in one or more activity, otherwise thinks that this task fails.Soft real-time system is such system, that is, this system has clocking requirement, but as long as application requirements continues to be met on the whole, then misses these clocking requirements once in a while and have insignificant effect.At last, the non real-time system is to be the non-again soft real-time system of non-hard real-time.Un-real time job does not have any final term or timing constraint.In many modern Application, must support various real-time system performances.For example, consider the requirement of the network equipment to Secure Application.The network equipment may be sampled to each network packet on express network connects and do not missed single grouping (hard real-time task).The hard real-time task will leave these groupings in the impact damper in subsequently it is handled.This can use hRTOS to realize.Must handle and classify these packet samples in this impact damper, but once in a while be that if handle and classification slows down, then as long as this impact damper does not overflow, (soft real-time task) just will not have problems.This can use the task among the hRTOS and the combination of the task among the GPOS to realize.When request, can use the webserver to come to sending of having handled with classified data.Usually do not exist this movable timing constraint (that is un-real time job); Therefore, can in GPOS, carry out this task.

In view of the above, exist for realize many in the system of nuclear environments () needs for example, GPOS and RTOS, this system provides the performance and the feature of many kernels effectively and easily and supports various real-time performances.

Summary of the invention

In order to realize above-mentioned and other purposes, and according to purpose of the present invention, for the executed in parallel between a plurality of kernels and resource sharing provide multiple technologies.

A kind of method, system, computer code and the device that are used for a plurality of kernels of nuclear environment executed in parallel in many have been described.In a method embodiment of the present invention, main kernel and at least one secondary kernel have been disposed, at least one secondary kernel is under the controlling to small part of described main kernel, and disposed optional common scheduler, this common scheduler is dispatched the execution of processing unsettled at least one secondary kernel of described main kernel and described secondary kernel, and disposed the common interrupt processor, this common interrupt processor is handled the interruption at least one the secondary kernel in described main kernel and the described secondary kernel and the execution of Interrupt Process.According to another embodiment, also provide a kind of device that is used to realize said method.According to another embodiment, also provide the computer code that is used to realize said method.

Other method embodiment of the present invention is provided, shared system resource between a plurality of kernels of nuclear environment in how being used for, wherein, main kernel and at least one secondary kernel have been disposed, described at least one secondary kernel described main kernel to small part control, and disposed and be used between kernel, carrying out the application programming interfaces (API) that system resource is shared, called kernel and be provided with at least some the suitable pseudo-API Calls that is used for other kernels.According to another embodiment, also provide the device that is used to realize this method.According to another embodiment, also provide the computer code that is used to realize this method.

From the following detailed description that should read in conjunction with the accompanying drawings, other features of the present invention, advantage and purpose will become more clear and easy to understand more.

Description of drawings

In the accompanying drawings, the mode by example but not explain the present invention by the mode of restriction, and in the accompanying drawings, similar label is represented similar element.In the accompanying drawings:

Fig. 1 illustration according to the figure of the example architecture that makes it possible on a hardware platform a plurality of kernels of operation of the embodiment of the invention;

Fig. 2 illustration according to the process flow diagram of method that is used for moving concurrently a plurality of kernels of the embodiment of the invention;

Fig. 3 illustration according to the process flow diagram of the illustrative methods of the selection that is used for the main kernel described in Fig. 2 of the embodiment of the invention;

Fig. 4 illustration according to the process flow diagram of the illustrative methods that is used for the main kernel of startup described in Fig. 2 of the embodiment of the invention;

Fig. 5 illustration according to the process flow diagram of the illustrative methods of the selection that is used for (a plurality of) secondary kernel described in Fig. 2 of the embodiment of the invention and interpolation;

Fig. 6 illustration according to the process flow diagram of the illustrative methods that is used for the startup secondary kernel described in Fig. 2 of the embodiment of the invention;

Fig. 7 illustration according to the block diagram of the example architecture of the common interrupt processor that is used for a plurality of kernels of the embodiment of the invention and common scheduler;

Fig. 8 illustration according to the example chart of the interrupt mask level of a plurality of kernels of the situation that is used for Fig. 7 of the embodiment of the invention;

Fig. 9 illustration according to other aspects of the interrupt mask level of a plurality of kernels shown in the bar chart of the block diagram that is used for Fig. 2 of the embodiment of the invention and Fig. 8.

Figure 10 illustration according to the process flow diagram that is used for switching the illustrative methods of kernel of the embodiment of the invention by periodic signal;

Figure 11 illustration the block diagram of the embodiment of the invention, wherein, public system called be used for the resource sharing of many kernels; And

Figure 12 illustration typical computer system, this computer system is being carried out suitable configuration or when design, it can be as can specifically implementing computer system of the present invention therein.

Except as otherwise noted, otherwise needn't measure diagram in the accompanying drawing in proportion.

Embodiment

The present invention is understood in explanation by reference drawings in detail and elaboration here best.

Embodiments of the invention are described in detail in detail with reference to the accompanying drawings.Yet those of skill in the art will readily appreciate that the detailed description about these accompanying drawings given here is for illustration purposes, and scope of the present invention exceeds these limited embodiment.

With the one aspect of the present invention that describes in detail slightly below is will operate two or more operating system nucleuss and the feature and the ability that keep these two operating system nucleuss simultaneously.

Many motivations that usually, may have many kernels of exploitation system.Four reasons are:

1. the Performance Characteristics of a kernel may be desired in another kernel (for example, real-time function may be desired in the general-purpose operating system)

2. the feature of an operating system (or kernel) may be desired in another operating system (or kernel) (for example, file system, device driver, real-time API, storehouse)

3. in some cases, remove needs, reduce cost of products thus specialized hardware by using many kernels system

4. may exist for supporting needs various real-time performances, that comprise the system of hRTOS and GPOS.

Fig. 1 illustration according to the figure of the example architecture that makes it possible on a hardware platform a plurality of kernels of operation of the embodiment of the invention.As shown in the drawing, carry out a plurality of kernels that indicate kernel 0, kernel 1, kernel 2, kernel n indicating on the conventional central processing unit of " CPU ".Should understand, although this figure and following discloses content have illustrated and have described in detail embodiment and example in the situation of single cpu system, but according to teaching of the present invention and according to known technology, the present invention is not limited to single CPU and realizes, and can carry out suitable being configured to and use multi-CPU system suitably to carry out teaching of the present invention.Here, claim that kernel 0 is main kernel, kernel 1, kernel 2 ..., the kernel of the some carried out by kernel 0 of kernel n representative, the quantity of kernel may be subjected to the restriction of system resource usually.These kernels can belong to the general-purpose operating system (GPOS) or real time operating system (RTOS), and each kernel can vary widely in feature that it provided and ability.

Next will describe kernel selection of the present invention aspect slightly in detail.Fig. 2 illustration according to the process flow diagram of method that is used for moving concurrently a plurality of kernels of the embodiment of the invention.Each step in this shown processing will illustrate in subsequent drawings in more detail individually.This processing by be chosen in the step 210 select have maximum capacity and at most the general-purpose operating system of features or operating system kernel (for example, those kernels among Fig. 1), and in step 220, start main kernel (kernel 0) as main kernel (kernel 0) beginning.In the situation of this example, start this main kernel and comprise the hardware guiding loader that powers up, packs into, this guiding loader is suitably packed into or is carried out kernel 0.Kernel 0 starts interrupt handler, scheduler, task manager etc. when starting, and comes system hardware is carried out initialization by suitable driver is installed.Then, in step 230, be added on do not possess in this main kernel but the kernel that possesses of expectation with the desired special characteristic of given intended application as the dynamic module of this main kernel (for example, kernel 1, kernel 2 ..., kernel n).This handles the circulation at step 230 place, gets back to step 230, till the kernel that has added all expectations.

Each secondary kernel preferably is assigned with unique kernel identification means (ID) when activating, slightly at length illustration is somebody's turn to do the use that identifies below.These kernels of predistribution ID preferably.In step 240, according to preallocated interrupt mask and kernel ID, select by checking the kernel that has added in the master, then in step 250, activate (or secondary) kernel kernel 1 of having added, kernel 1 ..., kernel n is as dynamic module.

Fig. 3 illustration according to the process flow diagram of the illustrative methods of the selection that is used for the main kernel described in Fig. 2 of the embodiment of the invention.This processing is in step 310 beginning of the common interrupt processor of the ability of selecting to have expectation and feature.Then in step 320, the kernel under this common interrupt processor is appointed as main kernel.In step 330, the selection scheduling device is as common scheduler.This scheduler can be the scheduler of main kernel or any other kernel.The needs that depend on concrete application, alternative embodiment of the present invention can realize or make on the contrary winner's kernel and/or native system can use any suitable interrupt handler or scheduler.In another embodiment of the present invention, can there be the main control kernel, but controls all kernels in many kernels system by public task scheduler and common interrupt processor, these kernels are directly control mutually.In another embodiment of the present invention, can not use the interrupt handler of main kernel, but outside main kernel, realize another interrupt handler, in this case, the interrupt handler emulator can be realized according to known technology, and other novel aspect of the present invention can be realized in addition.Should be understood that in the present embodiment the kernel that its acquiescence interrupt handler is used for the common interrupt processor automatically becomes the main kernel of many kernels system.What will also be understood that is, in some applications, system designer can be selected to remove the acquiescence interrupt handler of main kernel and replace it with another interrupt handler, wherein, under arbitrary situation, with main kernel can with effective interrupt handler think a part at the kernel of the purpose of present embodiment.The diversity that changes according to other suitable realizations of the common interrupt processor of teaching of the present invention will become clearer for those of skill in the art.

Get back to Fig. 3, in step 340 and step 350, respectively unique ID and interrupt mask level are distributed to main kernel.To describe interrupt mask level slightly in detail below.

Fig. 4 illustration according to the process flow diagram of the illustrative methods that is used for the main kernel of startup described in Fig. 2 of the embodiment of the invention.This handles step 410 beginning at the common interrupt processor that main kernel is installed.Common scheduler then is installed in step 420.Common application interface (API) is installed in step 430 is used for resource sharing.Known in advance, whether will there be one or more secondary kernel, perhaps, which kind of specific resources of selected secondary kernel will be available to resource sharing.The public API that is used for resource sharing allows the unlimited of resource to share, and need not to know in advance the details of resource API.In step 440, installation period task or processing, this periodic duty or handle according to the handover scheme of the expectation of depending on concrete application execution is switched to the secondary kernel.In a preferred embodiment, interrupt triggering switching between the kernel by hardware timer.The needs that depend on concrete application, those of skill in the art can according to teaching of the present invention come suggestion other suitable may be non-periodic or event driven handover scheme.Mode by example but not mode by restriction comprise cycle regimen, non-periodic scheme, based on the scheme of incident, can be used for switching between the kernel based on the suitable kernel handover scheme of the scheme of priority.

Fig. 5 illustration according to the process flow diagram of the illustrative methods of the selection that is used for (a plurality of) secondary kernel described in Fig. 2 of the embodiment of the invention and interpolation.This is handled in step 510 beginning, and in this step, selection has from the ability of one group of expectation of the needs derivation of the system that many kernel software will be installed therein and the secondary kernel of feature.In step 520 and step 530, unique ID and interrupt mask level are distributed to the secondary kernel respectively.

Fig. 6 illustration according to the process flow diagram of the illustrative methods that is used for the startup secondary kernel described in Fig. 2 of the embodiment of the invention.This is handled in step 610 beginning, and in this step, the what is called " linker (hook) " that will be used for the secondary kernel is installed to the common interrupt processor of main kernel.Then in step 620, the linker that will be used for the secondary kernel is installed to common scheduler.In step 630, the linker that will be used for the secondary kernel is installed to common application DLL (dynamic link library) (API).The feasible control path of having realized the application of the control from main kernel (for example, interrupt handler or scheduler or public API) of this linker to the specific secondary kernel that is associated with this linker.

Next will describe interrupt mask of the present invention and kernel priority aspect slightly in detail.All modem computer systems all have the interruption that can optionally enable or forbid.Which interruption is interrupt mask level determine to allow and which does not allow interrupt processor is interrupted.Fig. 7 illustration according to the block diagram of the example architecture of the common interrupt processor that is used for a plurality of kernels of the embodiment of the invention and common scheduler.In the figure, the level of masking of kernel 0 is such so that allows all interruptions.In a preferred embodiment of the invention, distribute the interruption scope of only when this kernel moves, just enabling for each secondary kernel.In the present embodiment, this realizes by using the level of masking.

Most of modern processors are supported interrupt mask level.As noted above, the kernel level of masking determines which interruption kernel allows and do not allow which interruption.Yet it should be noted that even interrupting may be that kernel allows, handle it but also may can't help this kernel.Therefore, present embodiment has three interrupt conditions about kernel and interruption: (1) kernel can block interruption, and (2) kernel can allow to interrupt but this interruption do not handled, and (3) kernel can allow to interrupt and this interruption is handled.Suppose and give this kernel the interrupt distribution of certain kernel permission and processing.In addition, kernel 0 allows and handles all interruptions.Also each can be interrupted distributing to uniquely arbitrary other kernels.Therefore, under the method for present embodiment, interruption must be that kernel 0 allows and handles, and one and only other kernels can allow and handle this interruption.Some embodiments of the present invention also provide priority for interrupting, and can specify these priority by the design of CPU, are perhaps specified by the additive method known to the those of skill in the art.

In the typical case of present embodiment uses, in the designing treatment of many kernels system, preferably specify priority of interrupt, so that give kernel with the highest execution priority with the interrupt distribution of limit priority.As shown in Figure 7, kernel 1 has the priority that is higher than kernel 0, and kernel 2 has the priority that is higher than kernel 1, or the like.Kernel n has the highest priority.Therefore, kernel 0 can by kernel 1, kernel 2 ..., kernel n takes the lead.Kernel 1 can be taken the lead to kernel n by kernel 2.Kernel n can not be taken the lead by any kernel.According to teaching of the present invention, interruption prioritisation scheme other alternatives and suitable will easily become clear for those of skill in the art.

Next will describe Interrupt Process of the present invention aspect slightly in detail.Novel aspect of the present invention is at first the common interrupt processor to be selected.The kernel that is associated with this common interrupt processor is called main kernel.In a preferred embodiment, by kernel 0 interrupt handler all interruptions are handled.When receive interrupting (710), kernel 0 is carried out non-kernel specific interruption service routine, and then control is delivered to the interrupt handler of the kernel that this specific interruption distributes to.Refer again to Fig. 7, when the interruption N that distributes to kernel n takes place, at first by kernel 0 processor it is handled, call the Interrupt Service Routine of kernel n then, kernel n is called target kernel (720) at this in this case.It should be noted that when calling interrupt handler interrupt handler is carried out kernel independence Interrupt Process function; And, control is delivered to the Interrupt Service Routine of target kernel.Use interrupt mask level to come preferably recognition objective kernel.In this mode, the interrupt handler of kernel 0 is as the common interrupt processor of many kernels system.

Fig. 8 illustration according to the example chart of the interrupt mask level of a plurality of kernels of the situation that is used for Fig. 7 of the embodiment of the invention.How this interrupt mask level that illustrates in the present embodiment is used to each to interrupt determining the target kernel.On the left side of this chart or axle, interrupt number is depicted as and rises sequence number, the total quantity of N for interrupting.

(or most of blank) got ready the zone (810) of vertical bar illustrates the interruption that corresponding kernel is handled and allowed.Shadow region (820) illustrates the interruption that corresponding kernel allows.Fragment of brick texture region (830) illustrates when corresponding kernel is just moving, promptly under the control of CPU time, and the interruption that gets clogged.

Fig. 9 illustration according to other aspects of the interrupt mask level of a plurality of kernels shown in the bar chart of the block diagram that is used for Fig. 2 of the embodiment of the invention and Fig. 8.Shown in this Figly how to determine kernel for the level of masking and will handle which interruption, kernel can be forbidden the example which interruption which interruption and given kernel can enable.On the left side of this chart or axle, interrupt number is depicted as and rises sequence number (910), the total quantity of N for interrupting.

Specifically, in the vertical bar at rightmost bar place, i kernel is expressed as Ki, the interruption that " ai " (920) expressions can be enabled by kernel Ki, " bi " (930) expression can be by the interruption of kernel Ki forbidding, and " ci " (940) expression can be by the interruption of kernel Ki processing.

Next will describe scheduling of the present invention aspect slightly in detail.In most of legacy operating systems, use hardware timer periodically to call scheduler.Usually hardware timer is set to trigger cycle interruption with the starting scheduling events.Each kernel in many kernels system can depend on the purpose of this operating system and have the different cycle that is used to call scheduler.Without limitation for example, under the situation of the general-purpose operating system, 10 millisecond periods may be enough for the performance of expectation.Yet, under the situation of real-time kernel, may must per 100 milliseconds have scheduling events one time.

In the present embodiment, select common scheduler for many kernels system.All scheduling events are preferably at first received by this common scheduler.After carrying out kernel independence scheduling feature, this scheduler preferably transmits the control (730) of the scheduler of the kernel of current operation.For the purpose of this example, the kernel of current operation is defined as the kernel of operation when scheduling events takes place.

Next will describe many kernels execution of the present invention aspect slightly in detail.Even another novel aspect of the present invention is when the kernel of higher priority is being carried out, system also allow when chance occurs (, task in the kernel of high priority is in running status-for example, wait, sleep, dormancy ... etc.) carry out the task in the kernel of lower priority.

Figure 10 illustration according to the process flow diagram that is used for switching the illustrative methods of kernel of the embodiment of the invention by periodic signal.In the embodiment shown in this figure, generic core (kernel 0, not shown) cycle of operation processing, this period treatment comes to switch to another kernel from a kernel by produce the periodic signal that triggers the kernel hand-off process in step 1005, and this processing begins at first to determine to exist any unsettled task in another kernel thus.This can realize by many suitable methods; This there is shown a suitable method, wherein, has adopted a series of polling methods to determine whether the kernel in the chain has any unsettled task that will carry out.In the example shown, when in step 1005, producing periodic signal, any unsettled task that will carry out of kernel 1 poll.If kernel 1 has one or more the unsettled task that will carry out ("Yes" path), then for example the id by current operation id being changed into kernel 1 should (a plurality of) unsettled task realizes (a plurality of) unsettled task executions in the kernel 1 thus CPU time is converted to execution.If kernel 1 does not have the unsettled task ("No" path) that will carry out, then should handle and continue next kernel of poll; For example the kernel in the step 1,020 2 continues this processing in an identical manner at each the follow-up kernel in the chain, till reaching last kernel (the kernel n in the step 1030).In case executed in the kernel all unsettled tasks or do not find unsettled task (that is) by the "No" path of step 1010 to 1030, this processing has just stopped, and restarts to carry out kernel 0 task.Yet, in alternative embodiment more of the present invention, not before returning, must finish all unsettled tasks to the control of main kernel, but can realize another poll or handover scheme according to known technology (without limitation for example, at first only serve the kernel of limit priority, and follow the lower priority kernel of service on approach subsequently etc.) before control is turned back to main kernel, to serve at least a portion of unsettled processing.This processing restarts when producing next periodic signal in step 1005.The needs that depend on concrete application, those of skill in the art will recognize according to the multiple alternative of teaching of the present invention and suitable handover scheme.

Next will describe many kernels resource sharing of the present invention aspect slightly in detail.Another novel aspect of the present invention is and can and shares resource between the secondary kernel between main kernel and any secondary kernel.In many application, the feature and the resource of other operating system nucleuss used in expectation from an operating system nucleus usually.In some cases, this may be the main promoting factor that realizes many kernels system.

Figure 11 illustration the block diagram of the embodiment of the invention, wherein, public system API is used for the resource sharing of many kernels.In the present embodiment, by for support between main kernel and the secondary kernel resource sharing (for example, file system, device driver, storehouse etc.) each kernel define pseudo-API system call (for example, system call 1, system call 2 ..., system call n) realize the resource sharing of many kernels.In a preferred embodiment, main kernel has the pseudo-API Calls at each kernel, and main kernel is supported the resource sharing between main kernel and the secondary kernel.When the activation of secondary kernel is the dynamic module of main kernel, replace pseudo-API Calls by true (actual) API Calls.

When main kernel is carried out true API Calls, secondary kernel calls and the corresponding specific function of this API call, and under the secondary kernel this function of operation.By this way, make winner's kernel can utilize the API of secondary kernel.Therefore, use the feature that (user and system) can obtain the secondary kernel.When user's application (1110) asked main kernel (1120) to carry out the API of kernel n, main kernel (1120) was used for the public API system call 0 (1130) of resource sharing and calls the public API system call n of the resource sharing that is used for kernel n (1140).Public API system call n (1150) invoke user that is used for the resource sharing of kernel n is used the specific API that is asked.

Specific embodiments of the invention are described in detail in detail below, and this embodiment is exemplified as this processing and is applied to Linux (GPOS) and iTRON (RTOS) operating system.Should be understood that how those of skill in the art will readily appreciate that any suitable GPOS and RTOS suitably are configured to teaching according to the present invention to be operated.Recognize as the present invention, comprise such as the GPOS of linux kernel and such as the commingled system of the RTOS of iTRON kernel will have many modern embedded devices the feature of expectation.

In the context of above-mentioned teaching, in the present embodiment, select linux kernel, and select iTRON as secondary kernel (k1) as general operation kernel (k0).Select the scheduler of Linux and interrupt handler common scheduler and common interrupt processor respectively as system.When starting computing machine, at first start linux kernel.Insert the working time dynamic module of iTRON kernel as linux kernel.For example unique kernel ID 0 and 1 is distributed to Linux and iTRON respectively.Can be the iTRON kernel 1 assigned interrupt level of masking 11 to 15 (for example being suitable in the Hitachi SH-4 realization).Therefore, for example if the iTRON kernel is moving the interruption with level of masking 1 to 10, then do not allow to interrupt.

Because with the common scheduler of Linux scheduler, so system uses hardware timer to call the Linux scheduler periodically as system.When triggering scheduling events, call this Linux scheduler.The kernel id of the definite kernel that when calling this scheduler, is moving of this Linux scheduler.If the kernel that is moving is Linux, so for example call linux schedule () function, as illustrated by following false code:

Two kernels of #define DUET_NUM_KERNELS 2/* hypothesis are (in the master

Examine for example for example itron of Linux and secondary kernel) */

#define?DUET_NUM_POINTERS 3

typedef?int(*duetptr)(unsigned?long)；

typedef?int(*duetptr2)(signed?long，unsigned?long，unsigned?long*，

unsigned?long*)；

int?linux_do_IRQ(unsigned?long)；

int?duet_running_kernel＝0；

int?linux_sys_call(signed?long?function_id，unsigned?long?argc，unsigned

long*arg_type，unsigned?long*arg_arr)

{

return?0；

}

duetptr duetptrarr[DUET_NUM_KERNELS][DUET_NUM_

POINTERS]＝

{

{linux_schedule，linux_do_IRQ，0}，

{0，0，0}

}；

duetptr2 duetptr2arr[DUET_NUM_KERNELS][DUET_NUM_

POINTERS]＝

{

{linux_sys_call，0，0}，

{0，0，0}

}；

asmlinkage?int?sys_duet_sys_call(signed?long?kernel_id，signed?long

function_id，unsigned?long?argc，unsigned?long*arg_type，unsigned?long

*arg_arr)

{

if(duetptr2arr[kernel_id][2])

return?duetptr2arr[kernel_id][2](function_id，argc，arg_type，

arg_arr)；

else

Return-200; The invalid kernel * of/*/

}

asmlinkage?void?schedule(void)

{

duetptrarr[duet_running_kernel][0](0)；

}

Can depend on which kernel moves and some interruption is shielded.For example, when the iTRON kernel is moving, all interruptions (for example, SH-4 realizes) with level of masking 1 to 10 are shielded.Take place if having the interruption of the level of masking 11 to 15, then call the Linux interrupt handler.The Linux interrupt handler is carried out non-iTRON private code, then uses do_IRQ to carry out the iTRON interrupt handler, as illustrated by following false code:

asmlinkage?int?do_IRQ(unsigned?long?r4，unsigned?long?r5，

unsigned?long?r6，unsigned?long?r7，

struct?pt_regs?regs)

{

return?duetptrarr[duet_running_kernel][1]((unsigned?long)&regs)；

}

In the present embodiment, secondary kernel (such as iTRON) is installed if desired, so main kernel is at first installed to switch the periodic signal that is implemented as purpose between kernel.This periodic signal can be triggered by hardware timer.When this periodic signal took place, interrupt handler determined whether there be any unsettled executing the task in secondary kernel (iTRON), if there is no, then execution is delivered to linux kernel.This permission was executed the task in main kernel the secondary kernel free time.

In the present embodiment, when main kernel (for example, linux kernel) was delivered to secondary kernel (for example, the iTRON kernel) with execution, the interrupt mask level of at first interrupt mask level being changed into this secondary kernel (iTRON) was preferred.Without limitation for example, when execution is sent to iTRON, interrupt mask level is set by calling linux_2_itron () as follows.Its interrupt mask is set to 0x000000A0.Now will only allow the interruption between 11 and 15.Take place if having the interruption of interrupt level 0 to 10, then ignore this interruption, as illustrated by following false code:

void?linux_2_itron(void)

{

/ * shielding */

duet_imasks＝0x000000A0；

/ * is provided with the iTRON scheduling, IRQ*/

duet_running_kernel＝1；

}

When carrying out when iTRON sends back Linux, interrupt mask is set to allow the 0x00000000 of all interruptions.It should be noted that before execution is transmitted, also kernel id is changed into the id of the kernel that this execution will be delivered to.For example, when carrying out when Linux is delivered to iTRON, kernel id changes into 1 from 0.When Linux was returned in execution, kernel id changed into 0 from 1, as illustrated by following false code:

void?itron_2_linux(void)

{

/ * is provided with the linux scheduling, IRQ*/

duet_running_kernel＝0；

The unshielded * of/*/

duet_imasks＝0x00000000；

}

On Hitachi SHx series processors, realize above system.Hitachi SHx processor and many other processors are all supported explicit interrupt priority level.In hardware, do not support in the system of interrupt priority level, can in software, realize interrupt priority level by emulation or some other technologies.

Most of traditional real time embedded systems use the programming based on incident; That is, when taking place, particular event executes the task.In the embedded computer system of good programming, the system CPU most of the time is in the rest idle condition.Great majority (if not all) Embedded Application can be considered as comprising three types task; This task of three types is that hard real-time (HRT), soft (SRT) and non real-time or routine (NRT) in real time will influence these task models and corresponding interrupt model in the embodiments of the invention that next will describe in detail slightly it.In this situation, another aspect of the present invention utilizes this typical case in the embedded system to improve the performance and the duty cycle of the general-purpose operating system free time.In the embodiment of the above-mentioned task model of influence of the present invention and system free time, the HRT task is embodied as one or more tasks in the RTOS kernel, for example use the iTRON kernel of iTRON API without limitation; Use one or more RTOS kernels to realize the SRT task, for example iTRON API and/or one or more GPOS kernel without limitation, for example Linux storehouse (system call and core A PI) without limitation; And, use one or more GPOS kernels to realize the NRT task, without limitation standard Linux API for example.

Present embodiment is suitable for using any combination of RTOS known or that wait to develop and GPOS system; Yet, clear for follow-up discussion, will suppose that RTOS is that iTRON and GPOS are Linux.According to the method for present embodiment, as long as there be unsettled executing the task in the iTRON kernel, Linux handles the chance with regard to not obtaining it is carried out.If there is carrying out more than a preparation of task, then at first execution has the task of limit priority, then carries out to have task of inferior limit priority or the like, till no longer existence is in the task of ready or pending status.

In the iTRON system, do not exist under the unsettled situation of executing the task, will carry out control and being delivered to Linux, wherein, equally at first carry out task with the highest execution priority.In order to keep the stand-by period reasonably little, all SRT tasks all have than standard Linux handles (that is NRT task) higher execution priority.In a preferred embodiment, use Linux " RT priority " to realize SRT among the Linux and the priority system between the NRT.Therefore, up to not existing unsettled the executing the task of SRT just to carry out the NRT processing.In the embodiment of alternative, can realize priority and scheduling that any suitable PD or proprietary priority management system handle with management HRT, SRT and NRT.

As mentioned previously, another novel aspect of the present invention is such processing, that is, handle a plurality of kernels by this and can share resource such as file system, device driver, storehouse etc.In one embodiment of the invention, define pseudo-API Calls by each kernel of sharing for support resource and realize this resource sharing processing.Without limitation for example, expect very much from the GPOS kernel (for example, use in Linux) the RTOS kernel (for example, iTRON) in available feature.Represent pseudo-API Calls by pseudo-code example without limitation below at the iTRON kernel:

#define?ITRON_BAS_ERR 300

int?itron_syscall(signed?long?function_id，unsigned?long?argc，unsigned

long*arg_type，unsigned?long*arg_arr)

{ switch(function_id)

/************************************************/

/ * function code */

/************************************************/

/ * 4.1 joint task management service call */

case?TFN_CRE_TSK:/*(-0x05)*/

case?TFN_DEL_TSK:/*(-0x06)*/

case?TFN_ACT_TSK:/*(-0x07)*/

/ * 4.4.1 joint beacon (semaphore) service call */

case?TFN_CRE_SEM:/*(-0x21)*/

return(cre_sem((ID)arg_arr[0]，(T_CSEM*)arg_arr[1])-ITRON_BAS

_ERR)；

case?TFN_DEL_SEM:/*(-0x22)*/

return(del_sem((ID)arg_arr[0])-ITRON_BAS_ERR)；

case?TFN_SIG_SEM:/*(-0x23)*/

return(sig_sem((ID)arg_arr[0])-ITRON_BAS_ERR)；

default:

return?INVALID_FUNCTION}

}

When initial activation (packing into) secondary kernel during, pseudo-API Calls is connected to true API as the dynamic operation time module.When under Linux, activating iTRON, replace pseudo-API Calls by true API Calls as dynamic module.By this way, make winner's kernel (for example, the Linux in this example) can utilize whole secondary kernels (for example, the iTRON in this example) API, illustrative without limitation as institute in following false code:

asmlinkage?int?sys_duet_sys_call(signed?long?kernel_id，singed?long

function_id，unsigned?long?argc，unsigned?long*arg_type，unsigned?long

*arg_arr)

{

if(duetptr2arr[kernel_id][2])

return?duetptr2arr[kernel_id][2](function_id，argc，arg_type，arg_arr)；

else

Return INVALID_KERNEL_; The invalid kernel * of/*/

}

duetptr2 duetptr2arr[DUET_NUM_KERNELS][DUET_NUM_

POINTERS]＝

{

{linux_sys_call，0，0}，

{0，0，0}

}；

For present embodiment being used for dynamic module working time of Linux, can use following false code by example and nonrestrictive mode:

void?duet_init_itron(void)

/ * is provided with the duet progress, IRQ*/

duetptrarr[1][0]＝itron_schedule；

duetptrarr[1][1]＝itron_IRQ；

Duetptr2arr[1] [2]=itron_syscall; / * installation itron_syscall*/

duet_imaskc＝0x000000D0；

duet_imasks＝0x00000000；}

When remove the RTOS module (for example, in the time of iTRON), as the pseudo-API that removes to illustration without limitation in following false code:

void?duet_deinit_itron(void)

{

Duetptr2arr[1] [2]=0; / * unloading itron_syscall*/

duet_imaskc＝0x000000F0；

duet_imasks＝0x00000000；

}

In this or similar mode, by using pseudo-API Calls, main kernel can be carried out the secondary kernel function that winner's kernel can be utilized by pseudo-API.Can expect that this mechanism makes can use two complex interactions between the kernel, this interaction includes but not limited to data sharing, tasks synchronization and communication function (beacon, event flag, data queue, mailbox).By using pseudo-API and (for example using GPOS, Linux) system call, according to teaching of the present invention, those of skill in the art can develop the program of enriching characteristic (for example, file system, driver, network etc.) that can utilize Linux in real-time embedded program.Some embodiments of the present invention may not comprise above-mentioned common scheduler and/or public pseudo-API, because they are optional.That is, can use common interrupt processor of the present invention to move a plurality of kernels, and need not common scheduler and/or public pseudo-API.Yet in many application, common scheduler provides the Error processing of augmented performance and Geng Jia.Do not need the application of the resource sharing between a plurality of kernels can not realize above-mentioned public pseudo-API of the present invention aspect.

Figure 12 illustration typical computer system, this computer system is being carried out suitable configuration and when design, it can be as can specifically implementing computer system of the present invention therein.Computer system 1200 comprises the processor 1202 (being also referred to as CPU (central processing unit) or CPU) of any amount, and processor 1202 is connected to the memory device that comprises primary memory 1206 (being generally random access memory or RAM), primary memory 1204 (being generally ROM (read-only memory) or ROM).CPU 1202 can be all kinds that comprise microcontroller and microprocessor, such as programmable device (for example, CPLD and FPGA) with such as the non-programmable equipment of gate array ASIC or general purpose microprocessor.As known in the art, primary memory 1204 is used as data and instruction uniaxially is sent to CPU, and uses primary memory 1206 to transmit data and instruction in a bi-directional way usually.These two primary memorys can comprise any suitable for those above-mentioned computer-readable mediums.Also mass memory unit 1208 can be connected to CPU 1202 two-wayly, and mass memory unit 1208 provides additional data storage capacity and can comprise any above-mentioned computer-readable medium.Mass memory unit 1208 can be used for stored programme, data etc., and mass memory unit 1208 is normally such as the secondary storage media of hard disk.Should be understood that in appropriate circumstances, can incorporate the information that keep in the mass memory unit 1208 into virtual memory with standard mode as the part of primary memory 1206.Special-purpose mass memory unit such as CD-ROM 1214 also can be with data sheet to passing to CPU.

Also CPU 1202 can be connected to interface 1210, interface 1210 is connected to one or more input-output apparatus, such as video monitor, tracking ball, mouse, keyboard, microphone, touch-sensitive display, sensor card reader (transducer card reader), magnetic tape reader or paper tape reader, graphic tablet, stylus, sound or handwriting recognizer or important achievement so such as other known input equipments of other computing machines.At last, optionally, can use outside that 1212 places generally illustrate to connect CPU 1202 is connected to external unit such as database, computing machine, communication network or internet.Use such connection, it is contemplated that, in the processing of the method step described in carrying out teaching of the present invention, CPU can perhaps can output to network with information from network receiving information.

Those of skill in the art will readily appreciate that, according to teaching of the present invention, any above-mentioned steps and/or system module can be replaced suitably, reset, removed, and the needs that depend on concrete application, can insert additional step and/or system module, and the method and system that can use multiple suitable processing and any processing in the system module and system module to realize present embodiment is not limited to any specific computer hardware, software, RTOS, GPOS, firmware, microcode etc.

Fully having described at least one embodiment of the present invention, to those skilled in the art, will be clearly according to the executed in parallel of a plurality of kernels of the present invention and other methods that be equal to or alternative of the resource sharing between a plurality of kernels.Below described the present invention by illustrative mode, disclosed specific embodiment is not intended to limit the present invention to disclosed concrete form.Therefore, the present invention desires to contain all modified examples, equivalent and the alternative example of the spirit and scope that fall into following claim.

The cross reference of related application

It is the rights and interests of 60/586486 U.S. Provisional Application that this PCT patented claim requires in the patent No. that on July 6th, 2004 submitted to according to 35U.S.C.119 (e).

Claims (20)

1, a kind of method of operating that is used to control embedded system, described method comprises:

The processor of described embedded system starts main kernel to control the operation of described embedded system;

Described processor starts the operation that at least one secondary kernel is assisted the described embedded system of nuclear control in the described master, expands the function of described embedded system, described at least one secondary kernel described main kernel to small part control; And

Described processor is operating as common scheduler with a scheduler, and this common scheduler is dispatched the execution of the processing of described main kernel and described at least one secondary kernel.

2, method according to claim 1, wherein, described main kernel is the general-purpose operating system.

3, method according to claim 1, wherein, at least one in described at least one secondary kernel is real time operating system.

4, method according to claim 1, wherein, described main kernel is more capable than each described at least one secondary kernel.

5, method according to claim 1, this method also comprises: described processor is operating as the common interrupt processor with an interrupt handler, the interruption of the described main kernel of described common interrupt processor processing and described at least one secondary kernel.

6, method according to claim 1, wherein, this method also comprises: described processor selects a more competent scheduler to be used as described common scheduler between one or more schedulers of the scheduler of described main kernel and described at least one secondary kernel.

7, method according to claim 5, this method also comprises: described processor selects a more competent interrupt handler to be used as described common interrupt processor between one or more interrupt handlers of the interrupt handler of described main kernel and described at least one secondary kernel.

8, method according to claim 7, wherein said selection step comprises: the interrupt handler of the described main kernel of described processor selection as described common interrupt processor or the scheduler of selecting described main kernel as described common scheduler.

9, method according to claim 1, wherein said processor started described main kernel before starting described at least one secondary kernel when the described embedded system of guiding.

10, method according to claim 1, wherein said processor starts at least one in described at least one secondary kernel, as dynamic module working time of described main kernel.

11, method according to claim 5, this method also comprises:

Described processor is given described main kernel with unique kernel identification distribution; And

At least one interrupt mask level is distributed to described main kernel, and described at least one interrupt mask level is determined the interruption that described main kernel allows.

12, method according to claim 5 also comprises:

Described processor is given described at least one secondary kernel with unique kernel identification distribution; And

Described processor is distributed to described at least one secondary kernel with at least one interrupt mask level, and described at least one interrupt mask level is determined the interruption that described at least one secondary kernel is allowed.

13, method according to claim 5 also comprises: described processor is installed at least one the linker that is used for described at least one secondary kernel in described common scheduler or described common interrupt processor.

14, method according to claim 1, this method also comprises: described processor is carried out the task of processing execution control being switched to next effective kernel from current effective kernel, wherein, described next effective kernel is in described at least one secondary kernel one.

15, method according to claim 14, wherein, described processing execution control task is a periodic duty, and described method also comprises: when the described main kernel of operation, described processor is defined as described next effective kernel by carrying out poll according to secondary kernel poll precedence scheme with one of described at least one secondary kernel, described next effective secondary kernel with limit priority has the unsettled processing that at least one will be carried out, and after at least a portion of described at least one the unsettled processing that will carry out of finishing described next effective secondary kernel with limit priority, described main kernel is shifted back in processing execution control.

16, method according to claim 12, this method also comprises: described processor calls described common interrupt processor, described afterwards common interrupt processor is carried out at least one kernel independence Interrupt Process function, and subsequently processing execution control is delivered to the Interrupt Service Routine of the target kernel that is associated with this interruption.

17, method according to claim 16 wherein, is determined described target kernel by the level of masking of described at least one secondary kernel.

18, method according to claim 4, this method also comprises:

Described processor calls described common scheduler;

Described processor determines which kernel is the current kernel of carrying out;

Described processor is transferred to the described current kernel of carrying out with processing execution control; And

Described processor is carried out at least one kernel particular schedule function of the kernel of current execution.

19, method according to claim 12, this method also comprises:

Described main kernel is controlled one that is delivered in described at least one secondary kernel with processing execution, and described at least one secondary kernel becomes effective kernel thus; And

Described main kernel changes the interrupt mask level of described main kernel to reflect that the secondary kernel that receives processing execution control becomes described effective kernel; And

Described main kernel changes the kernel authentication code of current operation, is designated described effective kernel will receive the described secondary kernel of carrying out control.

20, method according to claim 1, this method also comprises: described processor is installed and is used for the application programming interfaces that carry out resource sharing between described main kernel and described at least one secondary kernel.

Images