Preemptive operating system without context switching

• US 10,402,221 B2
• Filed: 12/28/2017
• Issued: 09/03/2019
• Est. Priority Date: 12/30/2014
• Status: Active Grant

• Current Assignee: Tyco Fire & Security GmbH (Johnson Controls International plc)
• Original Assignee: Tyco Fire & Security GmbH (Johnson Controls International plc)
• Inventors: Lipsio, Jr., Vincent J., Rasband, Paul B.
• Primary Examiner(s): Rampuria, Satish
• Application Number:
  US15/856,223
• Publication Number:
  US 20180136969A1
• Time in Patent Office: 614 Days
• Field of Search: 718101-108
• CPC Class Codes: G06F 9/461 Saving or restoring of program or task context
• CPC Class Codes: G06F 9/4812 by interrupt, e.g. masked
• CPC Class Codes: G06F 9/4843 by program, e.g. task dispatcher, supervisor, operating system
• CPC Class Codes: G06F 9/4881 Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues

Abstract

A device, such as a constrained device that includes a processing device and memory, schedules user-defined independently executable functions to execute from a single stack common to all user-defined independently executable functions according to availability and priority of the user-defined independently executable functions relative to other user-defined independently executable functions and preempts currently running user-defined independently executable function by placing the particular user-defined independently executable function on a single stack that has register values for the currently running user-defined independently executable function.

Claims

1. A computer program product tangibly stored on a computer readable hardware storage device, the computer program product for managing constrained computing devices, the computer program product comprising instructions to cause a processor to:

schedule user-defined independently executable root functions that have plural execution status states to execute by the processor from a single stack common to all of the user-defined independently executable root functions according to availability and priority of the user-defined independently executable root functions relative to other user-defined independently executable root functions;

execute an idle root function when none of the user-defined independently executable root functions are executing;

change a state of any of the user-defined independently executable root functions in a first state that is a run in a next pass state to a second state that is a ready to run state, wherein the user-defined independently executable root functions are each configured with a maximum allowed execution time;

service a watchdog timer when the idle root function associated with a lowest possible priority is serviced forcing execution of all of the user-defined independently executable root functions that are in the ready to run state within time constraints of the watchdog timer, wherein the time constraints are determined at a build time;

determine upon invocation of one of the user-defined independently executable root functions a new execution time corresponding to a particular maximum allowed execution time of the one of the user-defined independently executable root functions added to a current time; and

save the new execution time corresponding to the particular maximum allowed execution time of the one of the user-defined independently executable root functions added to the current time with a particular state of the one of the user-defined independently executable root functions on the single stack.

2. The computer program product of claim 1 wherein the computer program product is part of a real-time operating system for execution on a constrained device.

3. The computer program product of claim 1, wherein the instructions further cause the processor to:

adjust a value corresponding to a sum of the particular maximum allowed execution time of the one of the user-defined independently executable root functions and the current time in response to the one of the user-defined independently executable root functions being preempted.

4. The computer program product of claim 1 further comprising instructions to cause the processor to:

check a heartbeat timer of an active root function; and

cause a kill of the active root function when a configured time of the active root function is exceeded.

5. The computer program product of claim 1 wherein the instructions further cause the processor to:

invoke preemption by an interrupt service routine for a new function; and

mark a currently running user-defined independently executable function for execution upon return from the interrupt service routine.

6. The computer program product of claim 5 wherein when the new function completes running and returns, the instructions further cause the processor to pop stack usage of the new function and resume running the currently running user-defined independently executable function.

7. A method executed in a computing system that comprises a processor and a memory, the method comprising:

scheduling by the processor in the computing system, user-defined independently executable root functions that have plural execution status states to execute by the processor from a single stack common to all of the user-defined independently executable root functions according to availability and priority of the user-defined independently executable root functions relative to other user-defined independently executable root functions;

executing by the processor in the computing system, an idle root function, when none of the user-defined independently executable root functions are executing;

changing by the processor in the computing system, a state of any of the user-defined independently executable root functions in a first state that is a run in a next pass state to a second state that is a ready to run state, wherein the user-defined independently executable root functions are each configured with a maximum allowed execution time;

servicing by the processor in the computing system, a watchdog timer when the idle root function associated with a lowest possible priority is serviced forcing execution of all of the user-defined independently executable root functions that are in the ready to run state within time constraints of the watchdog timer, wherein the time constraints are determined at a build time;

determining by the processor in the computing system, upon invocation of one of the user-defined independently executable root functions, a new execution time corresponding to a particular maximum allowed execution time of the one of the user-defined independently executable root functions added to a current time; and

saving by the processor in the computing system, the new execution time corresponding to the particular maximum allowed execution time of the one of the user-defined independently executable root functions added to the current time with a particular state of the one of the user-defined independently executable root functions on the single stack.

8. The method of claim 7 wherein the method executes in a real-time operating system environment on a constrained device.

9. The method of claim 7 further comprising:

invoking by the processor in the computing system, preemption by an interrupt service routine for a new function;

marking by the processor in the computing system, a currently running user-defined independently executable function for execution upon return from an interrupt; and

when the new function completes running and returns, popping by the processor in the computing system all stack usage of the new function, and resuming running by the processor in the computing system, the currently running user-defined independently executable function.

10. The method of claim 8, further comprising:

adjusting by the processor in the computing system, a value corresponding to a sum of the particular maximum allowed execution time of the one of the user-defined independently executable root functions and the current time in response to the one of the user-defined independently executable root functions being preempted.

11. The method of claim 8 further comprising:

checking by the processor in the computing system, a heartbeat timer of an active root function; and

causing by the processor in the computing system, a kill of the active root function when a configuration time of the active root function is exceeded.

12. A constrained device comprises:

a processor device, configured to;

schedule user-defined independently executable root functions that have plural execution status states to execute by the processor device from a single stack common to all of the user-defined independently executable root functions according to availability and priority of the user-defined independently executable root functions relative to other user-defined independently root executable functions;

execute an idle root function when none of the user-defined independently executable root functions are executing;

change a state of any of the user-defined independently executable root functions in a first state that is a run in a next pass state to a second state that is a ready to run state, wherein the user-defined independently executable root functions are each configured with a maximum allowed execution time;

service a watchdog timer when the idle root function associated with a lowest possible priority is serviced forcing execution of all of the user-defined independently executable root functions that are in the ready to run state within time constraints of the watchdog timer, wherein the time constraints are determined at a build time;

determine upon invocation of one of the user-defined independently executable root functions a new execution time corresponding to a particular maximum allowed execution time of the one of the user-defined independently executable root functions added to a current time; and

save the new execution time corresponding to the particular maximum allowed execution time of the one of the user-defined independently executable root functions added to the current time with a particular state of the one of the user-defined independently executable root functions on the single stack.

13. The constrained device of claim 12 further comprising:

a sensor element for sensing a physical condition, the sensor element sending data for processing to the processor device, with the processor device applying one or more user-defined independently executable functions to the data.

14. The constrained device of claim 12 further comprising:

a network interface to interface the constrained device to a network.

15. The constrained device of claim 12 further comprising:

a storage device storing a real-time operating system for execution on the constrained device, with the real-time operating system comprising instructions that configure the processor device.