DE10110444A1 - Determining workload of computer apparatus running computer program by determining run time of tasks after completion and subtracting run times upon interruption - Google Patents

Abstract

The computer program is divided into several tasks (A,B,C), and each task includes at least one process. A time interval (T) is selected so that at least one task is started and ended during the time interval. After ending the (or each) task, the run time of the task is determined. If the ended task is interrupted by a further task, the run time of the further task is subtracted from the determined run time. Independent claims are also included for: (a) a storage device such as a ROM, RAM or flash memory for storing a computer program (b) a computer program (c) a device for determining the workload of a computer apparatus.

Description

The present invention relates to a method and a Device for determining the utilization of a Computing device. A computer program is on the computing device processed. The computer program is divided into several tasks divided and each task comprises at least one process.

The invention also relates to a memory element, in particular a read-only memory, a random access memory or a flash memory. There is a on the storage element Computer program stored on a computing device, in particular on a microprocessor, is executable.

Finally, the present invention relates to a Computer program running on a computing device, in particular on a microprocessor, is executable.

State of the art

A computer program in the sense of the present invention is, for example, a control program for controlling of technical processes and other functions in one Motor vehicle is used. The control program is on one Computing device, in particular on a microprocessor, one Control unit of a motor vehicle executable. The Control program is divided into several tasks and each Task comprises at least one process. The individual tasks  different priorities are assigned. The tasks can interrupt each other. The control program can be in a cooperative or in a preemptive mode be processed. The present invention applies to Processing of tasks by the computing device in the cooperative and in preemptive mode alike.

The processing of individual tasks of a control program in cooperative mode means that at different prioritized tasks to perform a higher priority Task to interrupt a currently running low priority task. Unlike in the preemptive Mode in which a higher priority task to be executed a currently running process of a low priority task interrupts, waits in cooperative mode the higher priority task the end of the Process of the low-priority task currently running from. Only then will the low-priority task interrupted and the higher priority task executed. When the higher priority task is finished, the low priority task continued with the process before which she was interrupted.

The processing of the tasks of a control program in the cooperative mode is known from DE 195 00 957 A1. Interrupting a low-priority task by a higher-priority task is one of the tasks of a multi-tasking operating system. Such a multi-tasking operating system, which supports both the cooperative mode and the preemptive mode when processing control programs, is, for example, the real-time operating system ERCOS ^EK from the company ETAS Development and Application Tools for Electronic Systems GmbH & Co. KG, Stuttgart, Germany (see ETAS GmbH & Co.KG: ERCOS ^EK V2.0.0 Manual, Stuttgart, 1998). Reference is expressly made to DE 195 00 957 A1 and the ERCOS ^EK manual.

During the operation of a computing device, this depends on Number of process calls and processing time of the called processes more or less busy. In time- or safety-critical applications, such as control of X-by-wire applications (steer-by-wire, Brake-by-wire, etc.) in a motor vehicle, one must heavy occupancy or even an overload of the Computing devices can be avoided because of an overload proper execution of the program no longer can be guaranteed. To the utilization of the Monitor computing device and if it is too strong To be able to take suitable countermeasures it is known to determine the utilization of the computing device. The countermeasures are, for example, the call targeted fewer time or safety-critical processes delay the calling and processing of special To enable time-critical or safety-critical processes.

Various methods are known for determining the utilization of a computing device. From DE 197 57 876 A1 it is known, for example, to call a separate idle program whenever the computing device is not fully utilized, ie no process is being processed on the computing device. The load on the computing device can be determined from the running time or the number of calls to the idling program during a predeterminable time interval (utilization of _{computing device} [%] = 100% - running time _{idling program} [%]). The calculated utilization represents a mean value filtered over a longer time interval. For this reason, the utilization of the computing device can only be determined with a very low dynamic using the known method.

Another disadvantage of the known method is that  the idle program only with a high load is rarely called and runs on the computing device. If the time interval under consideration is too short, it can happen that the idle program in the Time interval is not called and a 100% Utilization is determined, although the actual Utilization is lower. Likewise, the idle program only very weak when the computing device is under load rarely not called, namely not only if Processes of the computer program are processed. If the time interval under consideration is too short, can it happens that the idle program in the Time interval expires constantly and a 0% utilization is determined, although the actual utilization is higher is.

The present invention is based on the object on the one hand, the utilization of a computing device if possible accurate and reliable and with a high dynamic and on the other hand, the processing time of processes or tasks a computer program processed on the computing device regardless of interruptions caused by higher priority processes Identify tasks.

To achieve this object, the present invention, based on the method of the type mentioned at the beginning, proposes that

• - A time interval is chosen such that during of the time interval at least one task started and is ended again;
• - during the time interval after the or everyone has ended Task the runtime of the task is determined; and
• - if the completed task by at least one other Task was interrupted, the runtime of or everyone further task deducted from the determined runtime becomes.

Advantages of the invention

With the method according to the invention, the uninterrupted processing times of everyone in the Calculator active task can be determined. That happens by inserting suitable program commands on Start of processing and at the end of processing the tasks of Computer program. By adding the Processing times of all tasks within the predeterminable time interval are ended, and a subsequent normalization to the time interval, the percentage utilization of the computing device with almost any dynamics and without filtering or Averaging can be determined.

According to an advantageous development of the present invention, it is proposed that

• - The time interval is chosen such that during of the time interval at least two tasks started and be stopped again; and
• - The runtimes of the completed tasks in the order the completion of the tasks can be determined.

According to a preferred embodiment of the present invention, it is proposed that

• - a variable (interrupt) at the beginning of the procedure Is set to zero;
• - The runtime of the completed task is determined using the equation t _runtime = t _end - t _start - (interrupt _end - interrupt _start ); and
• a new value for the variable is determined using the equation interrupt = interrupt _start + (t _end - t _start ),

where t _start

the value of a time counter running during the processing of the computer program at the beginning of the task, t _end

the value of the time counter after the task has ended, interrupt _start

the value of the variable at the beginning of the task and interrupt _{at the end}

the value of the variable after the task has ended is.

To determine the utilization of the Computing device after the specified time interval the determined run times of the tasks are added up and in Relation to the time interval set.

The determined terms are preferably the individual tasks each in a separate memory cell of the Computing device, preferably in a random access memory (RAM) memory cell. For a subsequent one Calculation of utilization must ensure that in current runtime values are available to the memory cells stand. This can be done, for example, by deleting the memory cells after calculating the utilization or by overwriting the content of the memory cells after the calculation, for example. with zero or a current runtime value for the subsequent calculation.

The realization of the inventive method in the form of a Storage element. Here is on the storage element Computer program stored on a computing device, in particular on a microprocessor, executable and for Execution of the method according to the invention is suitable. In this case, the invention is based on a Storage element stored computer program realized so this with the computer program provided storage element in the same way the invention represents how the process, the execution of which Computer program is suitable. Can be used as a storage element in particular an electrical storage medium for use come, e.g. a read-only memory, a random access Memory or a flash memory.  

The invention also relates to a computer program for Execution of the method according to the invention is suitable, if it is on a computing device, especially on a Microprocessor, expires. It is particularly preferred if the computer program on a storage element, is stored in particular on a flash memory.

As a further solution to the problem of the present invention, starting from the device for determining the utilization of a computing device of the type mentioned at the beginning, it is proposed that the device

• - During a predefinable time interval after termination the or each task determines the runtime of the task; and
• - if the completed task by at least one other Task was interrupted, the runtime of or everyone subtracts another task from the determined runtime.

The device according to the invention is, for example, as a Control device of a motor vehicle designed for Control of technical processes and others Functions in the motor vehicle is used. The control unit has a computing device, in particular a microprocessor, on which a control program is executable. The Control program is divided into several tasks and each Task comprises at least one process. In the device are means for carrying out the method according to the invention realized. This allows the uninterruptible Processing times of everyone active in the computing device Task can be determined. By adding the Processing times of all tasks within the predeterminable time interval are ended, and a subsequent normalization to the time interval can also the percentage utilization of the computing device is determined become.  

drawings

Other features, applications and advantages of the Invention result from the following description of embodiments of the invention, which in the Drawing are shown. Thereby form all described or illustrated features for themselves or in any Combination the subject of the invention, regardless of their summary in the claims or their Relationship and regardless of their wording or Representation in the description or in the drawing. It demonstrate:

FIG. 1 is a flowchart of a, C divided control program in three tasks A, B;

Fig. 2 is a flow diagram of a method according to a preferred embodiment; and

Fig. 3 shows an inventive apparatus for processing the method of FIG. 2 according to a preferred embodiment.

Description of the embodiments

In Fig. 3 a control unit of a motor vehicle is designated in its entirety by the reference numeral 1. The control device 1 has a computing device which is designed as a microprocessor 2 . A computer program is stored on a memory element of control unit 1 , which is designed as a flash memory 3 . The computer program is designed as a control program for controlling technical processes, in particular in a motor vehicle. The control program can be processed on the microprocessor 2 . A data connection 4 , which is designed, for example, as a bus line, is provided between the microprocessor 2 and the flash memory 3 for data transmission. Various input variables 5 are present on the control unit 1 , which are, for example, the signals from sensors and sensors. The input variables 5 characterize the state of the functions to be controlled, the state of the motor vehicle or other states such as the weather conditions. On the basis of the input variables 5 , output variables 6 are determined in the control device 1 , which serve to control actuators or actuators. The output variables 6 are, for example, setpoints for controls.

The control program is divided into several tasks A, B, C (cf. FIG. 1), each task in turn comprising at least one process. A task A, B, C is called at a certain point in time or regularly with a certain sampling time and can be processed in a cooperative or in a preemptive mode. Each task A, B, C is assigned a specific priority. Task A has the lowest priority, Task C the highest. If two tasks are to be carried out simultaneously during the execution of the control program, the priorities of the two tasks are compared and the task with the higher priority is processed first.

If, for example, task A is processed and task B is to be executed, different cases can occur depending on the configuration of the tasks selected by a programmer:
If task A has a higher priority than task B (not the case in FIG. 1), execution of task B is waited until task A has ended.
If task B has a higher priority than task A (example from FIG. 1), processing of task A is interrupted and task B is executed. If the programmer has chosen to execute the tasks in the cooperative mode, the execution of task B waits for the end of the current process of task A. As soon as this process is finished, task A is interrupted and task B is executed. When task B ends, task A continues to run at the beginning of the process before it was interrupted to execute task B.

If the programmer completes the tasks in the has selected preemptive mode, task B interrupts the current process of task A and task B will executed immediately. Then Task A is at the interrupted process.

The interruption of a task by another task with a higher priority is one of the tasks of a multi Tasking operating system. The runtime of the processes fluctuates depending on the load on the computing device on which the Control program is processed. For this reason and due to the possible causes of other tasks Interruptions can affect the order of the process calls a repeated execution of one and the same Control program may be different. The terms of the individual tasks within a predefinable time interval can therefore be subject to fluctuations.

In order to determine the processing time of processes or tasks A, B, C of a control program executed on the microprocessor 2 independently of interruptions by processes of higher priority tasks, a method according to the invention is proposed, of which a flowchart is shown in FIG. 2. Based on the processing time of the individual processes or tasks A, B, C within a predeterminable time interval T, the utilization of the microprocessor 2 can also be determined precisely and reliably and with high dynamics using the method according to the invention.

The method begins in a function block 10 . The time interval T is specified in a function block 11 . The time interval T is selected such that at least one task A, B, C is started and also ended again during the time interval T. In a function block 12 , the execution of the control program (cf. FIG. 2) is initiated on the microprocessor 2 as normal. A query block 13 checks whether a task has ended. If so, the processing time t _{runtime_Task of} the completed task is calculated in a function block 14 using the following equation:

t _{Laufzeit_Task} = t _end - t _Start - (Susp _end - Susp _beginning)

where t _start the value of a time counter running during the processing of the computer program at the start of the task, t _end the value of the time counter after the task has ended, interrupt _start the value of a variable interrupt at the start of the task and interrupt _end the value of the variable interrupt after completion the task is.

A new value for the variable Susp following equation is then calculated in a function block 15:

Interrupt = interrupt _start + (t _end - t _start ).

A query block 16 checks whether the predetermined time interval T has already expired or not. If so, the sum t _{tot of} the processing time t _{runtime_Task of} all tasks that were completed in the predetermined time interval T is formed in a function block 17 . In a function block 18 , the total processing time t _{ges is} then set in relation to the predetermined time interval T in order to determine the utilization of the microprocessor 2 . The method according to the invention is ended in a function block 19 .

If it appears in the query block 13 that no task has ended, or if it appears in the query block 16 that the predetermined time interval T has not yet expired, the process branches to the function block 12 , where the execution of the control program is continued.

The method according to the invention from FIG. 2 is explained below using the control program from FIG. 1 as an example. The time interval T is set to T = 610-100 = 510 milliseconds. The variable interrupt is set to zero. Then the execution of the control program is started. The first task that is ended is task C. The processing time of this task C is determined:

t _{Laufzeit_C} = t _end - t _start - (Susp _end - Susp _beginning)
= 270-210-0
= 60 milliseconds.

The difference (interrupt _end - interrupt _start ) is set to zero because task C was not interrupted. The variable interrupt is then determined:

Interrupt = interrupt _start + (t _end - t _start )
= 0 + (270 - 210)
= 60 milliseconds.

The next task that is completed, turn the task C. This task C, the processing time is t _{Laufzeit_C} and the new value for the variable Susp calculated:

t _{Laufzeit_C} = t _end - t _start - (Susp _end - Susp _beginning)
= 350-310-0
= 40 milliseconds,

Interrupt = interrupt _start + (t _end - t _start )
= 60 + (350-310)
= 100 milliseconds.

Task B ends as the next task. For the task B, the processing time is t _{Laufzeit_B} and the new value for the variable Susp calculated:

t _{Laufzeit_B} = t _end - t _start - (Susp _end - Susp _beginning)
= 420 - 150 - (100 - 0)
= 170 milliseconds,

Interrupt = interrupt _start + (t _end - t _start )
= 0 + (420 - 150)
= 270 milliseconds.

Finally task A is finished. For the task A execution duration t _{Laufzeit_A} and the new value for the variable Susp calculated:

t _{Laufzeit_A} = t _end - t _start - (Susp _end - Susp _beginning)
= 530 - 100 - (270 - 0)
= 160 milliseconds,

Interrupt = interrupt _start + (t _end - t _start )
= 0 + (530 - 100)
= 430 milliseconds.

The total t _{tot of} the processing time of the individual tasks A, B, C is then t _tot = 430 milliseconds. At a predetermined time interval T of 510 milliseconds, thus a load of the microprocessor 2 of t _ges / T = 430/510 = 0.843 or yields 84.3% with the inventive process.

The method according to the invention can be implemented in a simple manner by modifying the control program in such a way that additional functionalities are programmed at the beginning and at the end of a task. The additional functionalities at the beginning of the task include reading in the counter reading of a continuous time counter and storing the counter reading under the variable t _start . In addition, the value of the variable interrupt start can be read in at the beginning of the task and a value can be saved in the variable interrupt _start . The additional functionalities at the end of the task include reading in the counter reading of the time counter and storing the counter reading under the variable t _end . In addition, the value of the variable interrupt can be read in at the end of the task and a value can be saved in the variable interrupt _end . Furthermore, the term t _{Laufzeit_Task} and the new value for the variable Susp calculated at the end of the task.

The utilization of a computing device can also be determined by the particularly effective calculation explained below. The following calculation is obtained by mathematically reshaping the calculation explained above. With the proposed particularly effective calculation, only one auxiliary variable auxiliary variable is required and only four additions have to be carried out. The auxiliary variable auxiliary var is calculated at the beginning of the task:

Auxiliary var = interrupt _start - t _start

At the end of the task is the delay time t calculated _{Laufzeit_Task} and the variable Susp:

t _{Laufzeit_Task} = t _end - Susp _end + Hilfsvar

Interr = t _end + auxiliary var.

According to yet another calculation of the utilization of the computing device, only two auxiliary variables auxiliary variable1 and auxiliary variable2 are required and only three additions have to be carried out. The first auxiliary variable auxiliary variable1 is calculated at the beginning of the task:

Auxiliary var1 = interrupt _start - t _start

At the end of the task, the second auxiliary variable Hilfsvar2, the term t _{Laufzeit_Task} and the variable Susp calculated:

Auxiliary var2 = t _end + auxiliary var1

t = _{Laufzeit_Task} Hilfsvar2 - Susp _end

Interrupt = auxiliary var2.

Claims (10)

1. Method for determining the load on a computing device ( 2 ) on which a computer program is processed, the computer program being subdivided into several tasks (A, B, C) and each task (A, B, C) comprising at least one process, characterized in that
a time interval (T) is selected such that at least one task (A, B, C) is started and ended again during the time interval (T);
the running time (t _{running time} ) of the task (A, B, C) is determined during the time interval (T) after the or each task (A, B, C) has ended; and
if the completed task (A, B, C) was interrupted by at least one further task (A, B, C), the runtime of the or each further task (A, B, C) is subtracted from the determined runtime (t _runtime ) , 2. The method according to claim 1, characterized in that
the time interval (T) is selected such that at least two tasks (A, B, C) are started and ended again during the time interval (T); and
the running times (t _{running time} ) of the completed tasks (A, B, C) are determined in the order in which the tasks (A, B, C) ended. 3. The method according to claim 2, characterized in that
a variable (interrupt) is set to zero at the beginning of the process;
the running time (t _{running time} ) of the completed task (A, B, C) using the equation
t _runtime = t _end - t _start - (interrupt _end - interrupt _start )
is determined; and
a new value for the variable (interrupt) based on the equation
Interrupt = interrupt _start + (t _end - t _start )
is determined
where t _start the value of a time counter running during the processing of the computer program at the beginning of the task (A, B, C), t _end the value of the time counter after the task (A, B, C) has ended, interrupt _{start of} the value of the variable ( Interrupt) at the start of the task (A, B, C) and Interrupt _{end is} the value of the variable (Interrupt) after the task (A, B, C) has ended. 4. The method according to claim 2 or 3, characterized in that the determined run times (t _{run time} ) of the individual tasks (A, B, C) each in a separate memory cell of the computing device ( 2 ), preferably in a random access memory ( RAM) memory cell. 5. The method according to any one of claims 2 to 4, characterized in that to determine the utilization of the computing device ( 2 ) after the predetermined time interval (T) the determined run times (t _{run time} ) of the tasks (A, B, C) and in relation to the time interval (T). 6. Storage element, in particular read-only memory, random access memory or flash memory ( 3 ), on which a computer program is stored, which can run on a computing device ( 2 ), in particular on a microprocessor, and for carrying out a method is suitable according to one of claims 1 to 5. 7. Computer program, characterized in that the computer program is suitable for executing a method according to one of claims 1 to 5 if it runs on a computing device ( 2 ), in particular on a microprocessor. 8. Computer program according to claim 7, characterized in that the computer program is stored on a memory element, in particular on a flash memory ( 3 ). 9. Device ( 1 ) for determining the load on a computing device ( 2 ) on which a computer program can be processed, the computer program being divided into several tasks (A, B, C) and each task (A, B, C) at least one Process includes, characterized in that the device
determines the running time (t _{running time} ) of the task (A, B, C) during a predefinable time interval (T) after the or each task (A, B, C) has ended; and
if the completed task (A, B, C) was interrupted by at least one further task (A, B, C), the runtime of the or each further task (A, B, C) is subtracted from the determined runtime (t _runtime ). 10. The device ( 1 ) according to claim 9, characterized in that the device has means for performing a method according to one of claims 2 to 5.