WO2019056263A1

WO2019056263A1 - Computer storage medium and embedded scheduling method and system

Info

Publication number: WO2019056263A1
Application number: PCT/CN2017/102701
Authority: WO
Inventors: 杨显旭; 许江成
Original assignee: 深圳市汇顶科技股份有限公司
Priority date: 2017-09-21
Filing date: 2017-09-21
Publication date: 2019-03-28
Also published as: CN109819674B; CN109819674A

Abstract

A computer storage medium and an embedded scheduling method and system, the method comprising: traversing the current value of the bits in a first integer corresponding to each task, the tasks corresponding to the first integer on a one to one basis, the bits in the first integer corresponding to the tasks corresponding to the events supported by the tasks on a one to one basis (S101); determining that the event corresponding to the bits with a first value as the current value in the first integer corresponding to the each task is a current event to be processed (S102); and invoking the task supporting the event to be processed to implement processing of the event to be processed (S103). The present method achieves good usage effects and also implements a lightweight and low resource consumption scheduling solution, capable of being used effectively in devices with scarce hardware resources; the method is easy to implement, resource consumption is low, and startup is fast. In practical applications, the present method can be used for ordinary task scheduling and for invoking deep hierarchical systems, and can reduce system coupling.

Description

Computer storage medium, embedded scheduling method and system

Technical field

The present application relates to the field of computer software, and in particular, to a computer storage medium, an embedded scheduling method, and a system.

Background technique

Embedded system is a kind of "special computer system designed for specific applications inside fully embedded control device". It is application-oriented, based on computer technology, software and hardware can be tailored to adapt to application system. A dedicated computer system with strict requirements on function, reliability, cost, size, power consumption, etc. Correspondingly, an embedded operating system (EOS) refers to an operating system for an embedded system, and generally includes a hardware-related underlying driver software, a system kernel, a device driver interface, a communication protocol, a graphical interface, Standardize browsers, etc. Operating systems widely used in the embedded field are: embedded linux, windows embedded, VxWorks, and Android, iOS, etc. for smartphones and tablets.

The embedded operating system is responsible for all software and hardware resource allocation, task scheduling, control, and coordination of concurrent activities of the embedded system. Multi-task scheduling systems, such as embedded scheduling systems, are embedded in these embedded operating systems to complete complex scheduling tasks of the system. This embedded scheduling system has the advantages of reasonable design, optimized, powerful and no need for application developers to design and develop.

However, such embedded systems usually require complex design, which easily leads to large memory resources consumption and long startup time of the embedded scheduling system, which leads to a series of problems. For example, this drawback becomes especially apparent when embedded systems are used in different fields, especially in the Internet of Things. Due to cost constraints, the hardware resources of hardware systems such as IoT devices are quite limited, and existing embedded systems cannot be applied to these devices for task scheduling. However, the embedded scheduling schemes currently applicable to these devices often have poor performance. And the problem of serious waste of resources.

Application content

The present application provides a computer storage medium, an embedded scheduling method, and a system, which are used to solve the problem that the existing embedded scheduling solution cannot balance the use effect, memory resource consumption, and startup time.

A first aspect of the present application is to provide an embedded scheduling method, including: traversing a current value of a bit in a first integer corresponding to each task, where the task is in one-to-one correspondence with the first integer, the task The bit in the corresponding first integer is in one-to-one correspondence with the event supported by the task; and the event corresponding to the bit with the current value of the first value in the first integer corresponding to each task is determined as the current pending An event; calling a task that supports the to-be-processed event, and processing the to-be-processed event.

A second aspect of the present application is to provide an embedded scheduling system, including: a query module, configured to traverse a current value of a bit in a first integer corresponding to each task, where the task and the first integer are one by one Correspondingly, the bit in the first integer corresponding to the task is in one-to-one correspondence with the event supported by the task; the query module is further configured to: in the first integer corresponding to each task, the current value is the first value The event corresponding to the bit of the value is determined as the current event to be processed; the processing module is configured to invoke the task supporting the event to be processed, and process the event to be processed.

A third aspect of the present application is to provide an embedded scheduling system including: at least one processor and a memory; the memory storing computer executing instructions; the at least one processor executing the memory stored computer executing instructions to Perform the method as described above.

A fourth aspect of the present application is to provide a computer storage medium having stored therein program instructions that, when executed by a processor, implement the method as previously described.

The computer storage medium, the embedded scheduling method and the system provided by the application, by assigning corresponding integers to tasks, allocating corresponding bits to the event, and designing the value of the bit corresponding to the event as a single bit value that does not interfere with each other, The value of the bit is used to indicate whether there is currently an event corresponding to the bit to be processed. In the process of task scheduling, by traversing the value of the bit in the integer corresponding to the task, the current waiting can be quickly and accurately determined. The event is processed, and the corresponding task is called to process the pending event. The scheme adopts the event-driven task scheduling method, so that all events of the task can be cached by integers, and realize a good use effect, and realize a lightweight and low resource consumption scheduling scheme, which can be effectively applied to hardware resource shortage. Equipment, and the solution is easy to implement, resource consumption is low, and startup is fast. In practical applications, the above solution can be used for scheduling common tasks as well as for calling deep hierarchical systems and reducing system coupling.

DRAWINGS

The drawings used in the description of the embodiments will be briefly described below. It is obvious that the drawings in the following description are only some embodiments of the present application, and those skilled in the art may also The figure obtains other figures.

1A-1E are schematic flowcharts of an embedded scheduling method according to Embodiment 1 of the present application;

FIG. 1F is a schematic diagram of an example of task registration;

1G is a schematic diagram of a scheduling process in Embodiment 1 of the present invention;

2A to 2B, 2D to 2G, and FIG. 2I are schematic flowcharts of an embedded scheduling method according to Embodiment 2 of the present application;

2C is a schematic diagram of a scheduling process in Embodiment 2 of the present invention;

2H is a diagram showing an example of a process of message buffering in Embodiment 2 of the present invention;

3A-3D are schematic structural diagrams of an embedded scheduling system according to Embodiment 3 of the present application;

4A-4D are schematic structural diagrams of an embedded scheduling system according to Embodiment 4 of the present application;

FIG. 5 is a schematic structural diagram of an embedded scheduling system according to Embodiment 5 of the present invention.

Detailed ways

The technical solutions in the embodiments of the present application are clearly and completely described in the following with reference to the drawings in the embodiments of the present application. It is obvious that the described embodiments are a part of the embodiments of the present application, and not all of the embodiments. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present application are within the scope of the present disclosure.

All technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention applies, unless otherwise defined. The terminology used herein is for the purpose of describing particular embodiments, and is not intended to be limiting. Some embodiments of the present application are described in detail below with reference to the accompanying drawings. The features of the embodiments and examples described below can be combined with each other without conflict.

1A is a schematic flowchart of an embedded scheduling method according to Embodiment 1 of the present application; as shown in FIG. 1A, the embodiment provides an embedded scheduling method, which is used to implement a lightweight, A scheduling scheme for low resource consumption, specifically, the embedded scheduling method includes:

Step 101: traverse a current value of a bit in a first integer corresponding to each task, where the task is in one-to-one correspondence with the first integer, and a bit in the first integer corresponding to the task and an event supported by the task One-to-one correspondence;

Step 102: Determine, in the first integer corresponding to each task, an event corresponding to a bit whose current value is the first value as a current pending event;

103: Call a task that supports the to-be-processed event, and process the to-be-processed event.

Specifically, the execution body of the embedded scheduling method may be an embedded scheduling system. In an actual application, the embedded scheduling system may be a medium storing related execution code, for example, a USB flash drive, etc.; or the embedded scheduling system may also be a physical device integrated or installed with related execution code, for example, a chip. , smart terminals, computers, etc.

In practical applications, different tasks support different events, that is, different tasks can handle different events. In this embodiment, each task is assigned a corresponding integer in advance, and corresponding bits are allocated for events supported by each task. Specifically, the method further includes: assigning a corresponding integer to each task, and assigning the integer bits of the task to the events supported by the task respectively. For example: suppose that the current support calls are task A, task B and task C. Among them, the events supported by task A have events A1 and A2; the events supported by task B have events B1, B2 and B3; The event handled is C1. Correspondingly, the task A is assigned an integer a, the task B is assigned an integer b, and the task C is assigned an integer c. The integers a, b, c can all include multiple bits, and the bit a1 of the integer a is assigned to the event A1. Bit A2 of integer a is assigned to event A2, bit b1 of integer b is assigned to event B1, bit b2 of integer b is assigned to event B2, bit b3 of integer b is assigned to event B3, Such a push, for each task, assigns its corresponding integer bit to the event supported by the task, specifically, the one-to-one correspondence between the task and the integer, the bit of the integer corresponding to the task, and the event supported by the task. One-to-one correspondence.

Specifically, the different values of the bits corresponding to an event may indicate whether the event currently needs to be processed. For example, if an event is currently received and needs to be processed, the bit value corresponding to the event is set to a corresponding value to represent that the event currently needs to be processed. Correspondingly, when the value of the bit corresponding to the event is another value, the event that does not need to be processed is represented.

Optionally, the method further includes: if a new event is detected, setting a value of a bit corresponding to the new event to the first value. Optionally, after the processing of the pending event is completed, the value of the corresponding bit may be updated to improve the accuracy of the subsequent scheduling. reliability. Correspondingly, the embedded scheduling method may further include: if the processing of the to-be-processed event is completed, setting a bit corresponding to the to-be-processed event to a second value. The first value and the second value of the first value and the second value are used to indicate that the values of the two are different, and the specific values may be customized, for example, the first value may be set. It can be 1, and the second value can be 0.

The new event mentioned here is a newly generated event that needs to be processed. For example, the new event may be an event received from outside the scheduling system, or may be triggered by an internal event of the scheduling system before processing. The generated event, in short, as long as there is a newly generated event to be processed, the bit corresponding to the event to be processed is set to a corresponding value. Specifically, the value of the bit corresponding to the event may include 1 and 0. Alternatively, 1 can be used to characterize the current existence of the event that needs to be processed, and 0 is used to characterize the event that is currently not needed to be processed. Correspondingly, in combination with the foregoing examples, the value of the bit corresponding to each event can be initially set to 0. Assuming that there are new events A1 and B2 currently detected, the bit a1 corresponding to the event A1 and the bit b2 corresponding to the event B1 are set to 1, and when the subsequent scheduling is performed, the values of the bits a1 and b2 are detected as 1, It can be determined that the events A1 and B2 corresponding to the bits a1 and b2 are pending events.

Optionally, in order to further save resources and space required for scheduling, an integer of a consistent number of bits may be allocated according to the number of events supported by the task. Correspondingly, as shown in FIG. 1B, FIG. 1B is a schematic flowchart of another embedded scheduling method according to Embodiment 1 of the present application. On the basis of Embodiment 1, the method further includes:

104: assign a first integer to each task, where the number of bits of the first integer corresponding to the task is consistent with the number of events supported by the task;

Step 105: Allocate the bits of the first integer corresponding to the task to the event supported by the task in a one-to-one correspondence.

For example, in the actual scenario, for each task that can be called, an integer is assigned to each task, and the number of bits corresponding to each task is consistent with the number of events supported by the task, and still combined with the foregoing example, for the task. A, the number of events it supports is two, then it is assigned an integer a with a bit of 2 (integer a includes bit [a1][a2]), and for task B, the number of events supported is three. Then, it is assigned an integer b with a bit of 3 bits (the integer b includes the bit [b1][b2][b3]), and for task C, the number of events supported is one, and the allocated bit is 1 The integer c of the bit (for example, the integer c includes the bit [c1]). After assigning the corresponding integer, for each task, the bits of the integer corresponding to the task are assigned to the task support one by one. In conjunction with the foregoing example, for task A, bits a1 and a2 are assigned to events A1 and A2, respectively (eg, a1 is assigned to event A2, a2 is assigned to event A1), and for task B, bits are used. Bits b1, b2 and b3 are assigned to events B1, B2 and B3, respectively (for example, b1 is assigned to event B2, b2 is assigned to event B1, b3 is assigned to event B3), and for task C, bit c1 is assigned to Event C1. Correspondingly, in the scheduling process, once a new event is generated, for example, the new event is C1, the value of the bit c1 corresponding to the new event C1 is set to a first value, for example, set to 1, and then traversed by each The current value of the bit in the integer corresponding to the task can quickly and accurately determine the event whose value is 1, that is, the event C1 is determined as a pending event, thereby calling the task supporting the event C1, that is, the task C, and processing the event C1. .

In practical applications, the integers corresponding to each task may be distributed in various ways, for example, may be discretely distributed or may be adjacently distributed. Among them, the discrete distribution method can set the position of the integer at will, so the flexibility is higher. Alternatively, the manner of adjacent distribution may be adopted to improve the integration of the integer distribution, so as to further reduce the consumption of processing resources when traversing the integer corresponding to each task. Correspondingly, in an implementable manner, for an integer corresponding to each task, the integers may be generated by establishing an integer array. Specifically, as shown in FIG. 1C, FIG. 1C is provided in Embodiment 1 of the present application. A flow diagram of an embedded scheduling method. Based on the first embodiment, 104 specifically includes:

1041: Establish, according to the number of the tasks, a one-dimensional integer array including a plurality of first integers, where the number of the plurality of first integers is consistent with the number of the tasks;

1042: Allocate the first integers in the one-dimensional integer array to the tasks in a one-to-one correspondence.

Specifically, according to the number of currently available tasks, a corresponding one-dimensional array is established, and the integers in the array are assigned to each task according to the one-to-one correspondence principle, and then, corresponding to each task The bits of the integer are assigned to the events supported by the task in a one-to-one correspondence. Optionally, the number of the bits of each integer may be consistent with the number of events supported by the corresponding task. For the specific solution, refer to the steps in the foregoing embodiments, and details are not described herein again. Specifically, in combination with the foregoing example, in the embodiment, for tasks A, B, and C, a one-dimensional integer array including three integers a, b, and c is established, and the integers a, b, and c are allocated one by one. For tasks A, B, and C, specifically, integer a can be assigned to task A, integer b can be assigned to task B, and integer c can be assigned to task C. Specifically, in this embodiment, all events are cached by a one-dimensional array of integers, and each task can be assigned an integer in the array as an event buffer of the events it supports. Optionally, the cache can be The default is 0, that is, the initial value of each bit can be set to 0, which means that there is no event that needs to be processed at present. Each event corresponds to one bit of an integer. If an event needs to be processed, the value of the bit corresponding to the event will be set to 1. After the event is processed, the bit will be processed again. Set to 0.

In this embodiment, an integer corresponding to each task is generated by establishing a one-dimensional array, thereby reducing processing consumption and time consumption, and improving scheduling efficiency, so that the scheduling scheme is better. Applicable to devices with limited hardware resources.

Based on the present embodiment, when performing scheduling, it is necessary to first find an event whose value of the bit is not 0, and then process the events. In this process, optionally, after determining the pending event to be processed, The characteristics of the bit order introduce priority control between events. In the process of processing, priority control of event processing is realized by sequentially polling bits in integers in bit order. Correspondingly, as shown in FIG. 1D, FIG. 1D is a schematic flowchart of still another embedded scheduling method according to Embodiment 1 of the present application. On the basis of Embodiment 1, before 105, the method further includes:

106: Determine the priority of each event; correspondingly, 105 specifically includes:

1051: Allocate the first integer bit corresponding to the task to the event supported by the task in a one-to-one correspondence according to the bit sequence and the priority of the event.

In the actual scheduling process, in order to improve the scheduling effect and user experience, the processing priority of each event may be different, some events need to be processed first, and some events may be suspended. In this solution, based on the characteristics that the event corresponds to the bit, and the bit order exists between the bits, the priority of the event processing is introduced, and the resources for priority scheduling need not be specifically configured, and the event processing priority is easily and conveniently implemented. Level control. Specifically, in this implementation manner, the priority of each event may be determined as needed, and after determining the priority, in combination with the foregoing implementation manner, the bit order and the priority of each event are considered while allocating bits for each event. Each event is assigned a corresponding bit according to the bit-order and time-priority consistent non-allocation principle. The agreement here includes the same or the opposite, that is, as long as there is a regular mapping relationship between the bit order and the priority of the event, for example, the bit order may be assigned in the same order as the event priority, or the bit order may be used. The principle is reversed from the principle of event priority and is not limited here.

Optionally, based on the foregoing event allocation scheme, if the allocation is performed according to the principle that the bit order and the priority of the event are the same, then when the event processing is performed, as shown in FIG. 1E, based on the implementation manner shown in FIG. 1D, 103 specifically includes:

1031: Call a task that supports the to-be-processed event for each pending event according to the bit sequence of the bit corresponding to the to-be-processed event, and process the to-be-processed event.

Specifically, after each task is assigned a corresponding integer, for each task, in the process of assigning its corresponding integer bit to its supported event, the priority of each event may be determined first, and then in bit order. The principle of consistent priority of events is allocated so that in the process of traversing the bits of each integer, determining the event to be processed and processing the event to be processed, the event to be processed may be processed in bit order. Since the correspondence between the bit order and the event priority is introduced in the process of previously allocating bits for the event, subsequent event processing based on the bit order is actually performing event processing according to the priority of the event.

In the foregoing embodiment, by combining the characteristics of the bit order and the priority of the event in the process of allocating the bit for the event, the subsequent event processing in the bit order simply and subtly utilizes the characteristics of the bit sequence to implement event processing. Priority control, which further saves resources required for scheduling.

Specifically, each task in the solution includes a task that can be invoked by the current scheduling system. In practical applications, if a call to a task needs to be implemented, the task needs to be registered in the scheduling system in advance. Correspondingly, based on the first embodiment, the method further includes: receiving a registration request, where the registration request includes a task processing function of the task; and performing function registration on the task according to the task processing function. Specifically, the specific solution of the function registration can be implemented in combination with the existing task registration scheme, and will not be described here. For example, for a scheduling system, there may be multiple tasks that can be called, as shown in FIG. 1F, and FIG. 1F is an example schematic diagram of task registration. Task registration is completed through data interaction between the task and the scheduler.

It can be understood that the steps in this embodiment may be used to represent a single execution process. In an actual application, the scheduling system may need to perform the above process cyclically to complete task scheduling and event processing. For example, as shown in FIG. 1G, FIG. 1G is an exemplary diagram of a scheduling process in Embodiment 1 of the present invention. In an actual application, after the system is started, it detects whether there is a pending event, and if so, invokes the corresponding task. The processing event is processed, and after the processing is completed, the process returns to perform a step of detecting whether there is a pending event. By analogy, scheduling is achieved during the reciprocating process. For the specific solution for detecting and processing the event to be processed, reference may be made to the relevant execution steps in the solution, and the repeated description is not repeated here. Optionally, in the foregoing process, if there is no pending event, the sleep state may be entered to save the power of the device or the consumed resource, and the subsequent may be based on the existing After the wakeup mechanism wakes up, it detects again whether there are pending events. Through this solution, it is possible to provide a simple and reliable access method for the scheduler to access.

The embedded scheduling method provided in this embodiment allocates a corresponding bit to the event by assigning a corresponding integer to the task, and designates the value of the bit corresponding to the event as a single bit value that does not interfere with each other, and the value of the bit is used. In the process of task scheduling, the current pending event can be quickly and accurately determined by traversing the value of the bit in the integer corresponding to the task, and then calling The corresponding task processes the pending event. The scheme adopts the event-driven task scheduling method, so that all events of the task can be cached by integers, and realize a good use effect, and realize a lightweight and low resource consumption scheduling scheme, which can be effectively applied to hardware resource shortage. Equipment, and the solution is easy to implement, resource consumption is low, and startup is fast. In practical applications, the above solution can be used for scheduling common tasks as well as for calling deep hierarchical systems and reducing system coupling.

In practical applications, for an event, it may be accompanied by a message associated with it. The processing of such an event needs to deal with these messages. Therefore, during the scheduling process, the message caching and processing mechanism may also be involved. .

In practice, a message pool can be used to cache various messages. Correspondingly, as shown in FIG. 2A, FIG. 2A is a schematic flowchart of an embedded scheduling method according to Embodiment 2 of the present application. On the basis of Embodiment 1, the embedded scheduling method further includes:

201: If a new event is detected and the new event includes a message, the message is cached to the message pool.

Specifically, if the detected new event includes a message, the message is cached in the message pool, and when the event is processed, the message is obtained from the message pool, and the event is processed to complete the processing of the event. . Correspondingly, as shown in FIG. 2B, FIG. 2B is a schematic flowchart of another embedded scheduling method according to Embodiment 2 of the present application. On the basis of the implementation manner shown in FIG. 2A, 103 may specifically include:

1032: Acquire a target message associated with the to-be-processed event.

1033: Call a task that supports the to-be-processed event, process the target message, and clear the processed target message. In this embodiment, for an event including a message, the processing of the event is completed by processing the message, and the processed message is cleared, thereby effectively saving the memory occupied by the message cache on the basis of implementing the event processing.

For example, as shown in FIG. 2C, FIG. 2C is an exemplary diagram of a scheduling process in Embodiment 2 of the present invention. Referring to the drawings, with reference to the accompanying drawings, FIG. 2C differs from FIG. 1G in that, when it is detected that there is an event to be processed, it is necessary to call a corresponding task and detect whether there is a message corresponding to the event. If there is a corresponding message, a new event for processing the message needs to be generated and cached. After that, the pending events that need to be processed are detected again. For the specific implementation method of each step, reference may be made to related content in the method embodiment.

Optionally, in the process of message caching, a memory dynamic allocation mechanism may be used to cache the message, that is, real-time allocation of a corresponding size of memory according to the current message size to implement message caching, and the flexibility of the solution. High but resource-intensive and complex to implement. Optionally, a fixed-length memory block can also be used to store the message, that is, a static fixed-size memory is preset to buffer the message, and the solution resource is small, but the preset memory size is fixed. Therefore, in order to ensure that there is enough message buffer space, a large memory is often set, and for a scenario with less current messages, a large memory resource is wasted.

In this regard, in order to implement the message cache reliably and efficiently, as shown in FIG. 2D, FIG. 2D is a schematic flowchart of another embedded scheduling method according to Embodiment 2 of the present application. On the basis of Embodiment 2, the embedded scheduling is performed. The method also includes:

202: Divide the memory in the message pool according to a preset granularity to obtain multiple memory blocks.

Correspondingly, 201 may specifically include:

2011: If a new event is detected and the new event includes a message, an idle target memory block is found from the plurality of memory blocks, and the message is cached to the target memory block.

The partitioning granularity may be set according to needs or experience, for example, 10 memory units are one granularity. Optionally, the partitioning granularity may be a single, that is, the message pool is divided into a plurality of memory blocks of equal size according to a partitioning granularity; or the partitioning granularity may be multiple, that is, the message pool is divided into sizes. The plurality of memory blocks are not equal, and the embodiment does not limit them here. Optionally, in order to improve the efficiency of the message cache, the memory in the message pool may be equally divided. By dividing the message pool into multiple memory blocks, distributed management of the memory of the message pool is realized. There is no need to dynamically allocate memory, and there is no need to limit the excessive fixed memory, thereby improving the efficiency of message buffering and saving resource consumption. Specifically, when the message cache is performed, the idle target memory block is found from the plurality of memory blocks, and the message is cached to the target memory block.

In this implementation manner, the message pool is divided into multiple memory blocks to implement distributed management. If the detected new event includes a message, and the message needs to be cached, the air memory is searched for from multiple memory blocks. The free memory block caches the message of the new event into the found memory block, improving the efficiency of the message cache and saving resource consumption.

Optionally, in order to find the free memory block in a faster and more accurate manner, as shown in FIG. 2E, FIG. 2E is a schematic flowchart of another embedded scheduling method according to Embodiment 2 of the present application, which is implemented in FIG. 2D. On the basis of the method, the method may further include:

203: Set a status identifier for each memory block, where the status identifier of the memory block is used to indicate whether the memory block is free.

Specifically, after the message pool is divided into multiple memory blocks, a state identifier is set for each memory block, and when it is necessary to find the free memory block, the state identifier of each memory block needs to be traversed to quickly and accurately determine the idleness. The memory block improves the efficiency of the message cache.

Among them, the status identifier can be in various forms. Optionally, in order to further reduce resource consumption, as shown in FIG. 2F, FIG. 2F is a schematic flowchart of still another embedded scheduling method according to Embodiment 2 of the present application. On the basis of the implementation manner shown in FIG. 2E, 203 is specifically Can include:

2031: Create a second integer, where the number of bits of the second integer is consistent with the number of the multiple memory blocks;

2032: Allocate the bits of the second integer to the memory block in a one-to-one correspondence. The status of the memory block is identified as a bit corresponding to the memory block, and different values of the bit corresponding to the memory block respectively indicate that the memory block is idle or not.

Specifically, after the message pool is divided into multiple memory blocks, according to the number of memory blocks, a second integer whose number of bits is consistent with the number of memory blocks is created, and the bits of the second integer are allocated according to a one-to-one correspondence principle. Give a block of memory, that is, each bit represents a block of memory. Since the bits themselves have an assignable property, different values of the memory blocks can be characterized by different values of the bits. For example, for a bit corresponding to a memory block, when the value of the bit is 1, the memory block is characterized as being non-idle, and when the value of the bit is 0, the memory block is characterized as being idle. The idle or non-idle here is used to indicate whether the memory block is occupied, that is, whether data is cached. Optionally, the unoccupied memory block can be set as an idle memory block, and all or part of the occupied memory block is set as a non-idle memory block.

In this embodiment, each memory block is allocated a corresponding bit, and the different values of the bit are used to characterize whether the memory block is idle, thereby simply and effectively characterizing the state of the memory block, further saving resource consumption, and improving the efficiency of message buffering. .

Based on the above status identifier, when the message of the event needs to be cached, the free memory block can be quickly found. Specifically, as shown in FIG. 2G, FIG. 2G is a schematic flowchart of another embedded scheduling method according to Embodiment 2 of the present application. On the basis of the foregoing implementation manner, 2011 may specifically include:

2012: If a new event is detected and the new event includes a message, traversing the status identifiers of the multiple memory blocks to find a target memory block whose status identifier is idle;

2013: Cache the message to the target memory block, and set a status identifier of the target memory block to be non-idle.

Specifically, the message pool is divided into multiple memory blocks, and a status identifier is set for the multiple memory blocks, where the status identifier may be a bit allocated for the memory block, and if the detected new event includes a message, Then, the state identifier of each memory block can be traversed, the free memory block can be quickly found, and the message is cached into the found memory block, and correspondingly, the status identifier of the memory block is updated to be non-idle, so as to improve subsequent search idle. The accuracy and reliability of the memory block.

In this embodiment, if a new event is detected, including a message, the idle memory block is quickly determined to perform message buffering based on the status identifier of each memory block, and the status identifier of the memory block is updated, thereby improving the efficiency and accuracy of the message cache. .

Specifically, in the process of finding a free memory block for message buffering, the number of memory blocks occupied by the message may be different according to the data size of the message. Accordingly, on the basis of the second embodiment, the message is described in 2011. The buffering to the target memory block may include: if the data volume of the message is not greater than the storage capacity of the single target memory block, buffering the message to the target memory block; if the data volume of the message is greater than The storage capacity of a single target memory block splits the message into a plurality of message blocks and caches the plurality of message blocks to a plurality of target memory blocks, respectively.

For example, as shown in FIG. 2H, FIG. 2H is a schematic diagram of a process of message buffering in Embodiment 2 of the present invention. Referring to the accompanying drawings, for a message, it is first detected whether there is currently a free memory block, and if so, Then, the size relationship between the message and the memory block is determined. Specifically, the difference between the memory block capacity and the message length can be calculated to obtain the result LEN. If LEN is not less than 0, the capacity of the memory block is sufficient to cache the message, and the message ends. Cache, if LEN is less than 0, you need to find another free memory block, use the two memory blocks as the memory block for buffering the message, and calculate the current memory block capacity again (this is used to cache the message) The difference between the sum of all memory blocks and the length of the message obtains the current result LEN, and so on, until the LEN is not less than 0, then the end The process of this message cache.

It can be understood that, in the case that the technical features do not conflict, the present embodiment may be implemented in combination with the foregoing other embodiments, for example, based on the status identifier to find the target memory block, and selecting one or more target memory according to the data amount of the message. The block is cached. In this manner, messages of different sizes can be cached to improve the reliability of the message cache.

In an actual application, in a scheme of caching an event message by looking up an idle memory block, a memory block in which different events are located is different, and a memory block storing the same message may be discontinuous, so in order to perform subsequent event processing As shown in FIG. 2I, FIG. 2I is a schematic flowchart of another embedded scheduling method according to Embodiment 2 of the present application. On the basis of Embodiment 2, the method may further include:

205: Generate a message header of the message, where the message header includes information about a memory block where the message is located;

Correspondingly, 1032 may specifically include:

1034: Determine a target message associated with the to-be-processed event;

1035. Obtain information about a memory block where the target message is located from a message header of the target message, and extract a message cached in a memory block where the target message is located as the target message.

Specifically, if a new event is detected, the message may be cached to an idle memory block. The specific cache method may refer to the foregoing solution. In the process of caching the message or after the cache, the message header of the message may also be generated. The header includes information about the memory block in which the message is located, for example, may include an identification of a memory block in which the message is stored. Subsequently, when processing the event to be processed, the memory block in which the message corresponding to the event to be processed is located may be determined based on the message header of each message, and the message corresponding to the event to be processed is extracted from the memory block. It can be understood that based on the matching between the amount of data of the message and the size of the memory block, the memory block information in which the message is located may have one or more. In addition, based on the foregoing embodiments, the memory block may have corresponding bits. Correspondingly, in one embodiment, the identifier of the memory block mentioned herein may also be an identifier of its corresponding bit.

In this implementation manner, the message header of the message is accurately and simply represented by the message header of the message, so that the cache location of the message is accurately and quickly determined, and the efficiency of subsequent message processing is improved.

Further, in order to be able to determine the message corresponding to the event to be processed, in an implementation manner, on the basis of the embodiment shown in FIG. 2I, the message header of the message further includes information about the event to which the message belongs; , 1034 may specifically include:

1036: Determine that the first message is the target message, and the message header of the first message includes the Information about pending events.

Specifically, if a new event is detected, the message may be cached to an idle memory block. The specific cache method may refer to the foregoing solution. In the process of caching the message or after the cache, the message header of the message may also be generated. The header includes information about the memory block in which the message is located and information about the event to which the message belongs, that is, information about the new event. Subsequently, when processing the event to be processed, the target message corresponding to the to-be-processed event may be determined based on the event information in the message header of each message, and the target message is extracted according to the memory block information in the message header of the target message, and Process the target message. In addition, based on the foregoing embodiments, the event may have corresponding bits. Correspondingly, in one embodiment, the identifier of the event mentioned herein may be the identifier of its corresponding bit. In this embodiment, by generating a message header of the message, the corresponding relationship between the event and the message is accurately and simply characterized, and the cache location of the message can be accurately and quickly determined, thereby improving the efficiency of subsequent message processing.

Optionally, in another implementation manner, the message header of the message further includes information about a task that supports an event to which the message belongs according to any one of the foregoing embodiments. Correspondingly, 1034 may specifically include:

1037: Determine that the second message is the target message, and the message header of the second message includes information of a task that supports the to-be-processed event.

Specifically, if a new event is detected, the message may be cached to an idle memory block. The specific cache method may refer to the foregoing solution. In the process of caching the message or after the cache, the message header of the message may also be generated. The message header includes information of a memory block in which the message is located and information of a task supporting an event to which the message belongs, that is, information supporting a task of the new event. Subsequently, when processing the event to be processed, the target message corresponding to the event to be processed may be determined based on the task information in the message header of each message, and the target message is extracted according to the memory block information in the message header of the target message, and The target message is processed. In addition, based on the foregoing embodiments, the event may have corresponding bits. Correspondingly, in one embodiment, the identifier of the event mentioned herein may be the identifier of its corresponding bit. In this embodiment, by generating a message header of the message, the corresponding relationship between the event and the message is accurately and simply characterized, and the cache location of the message can be accurately and quickly determined, thereby improving the efficiency of subsequent message processing.

Further, if an event includes multiple messages, the priority processing mechanism of the message may be introduced. Optionally, on the basis of any of the foregoing embodiments, the message header of the message further includes Message counting information; correspondingly, 1033 may specifically include:

1038. In accordance with the order of the counting information corresponding to the target message, sequentially, for each target information, invoke a task that supports the to-be-processed event, process the target message, and clear the processed target message.

Specifically, when the detected new event includes multiple messages, the message header may also include message counting information while buffering the multiple messages and generating a message header for the message. The form of the message count information mentioned here may be various, as long as the order can be reflected, for example, numbers 1, 2, 3, .... Specifically, the priority of the message may also be set according to requirements. For example, the priority is determined according to the order in which the messages are received, and the sooner the message is received, the higher the priority. Subsequently, when processing the message to be processed, the message may be sorted according to the message counting information in each message, and each message is processed in turn according to the order of the message counting information, and the corresponding processing may be called in the corresponding process. Task. And the messages that have been processed can be cleared to save memory space.

In this embodiment, by adding message count information to the message header of the message, the priority of the message processing is introduced, and the priority mechanism of the message processing is implemented simply and effectively.

Further, on the basis of any of the preceding embodiments, after clearing the processed target message, the method further includes: setting a status identifier of the memory block where the processed target message is located to be idle. According to the embodiment, the state identifier of the memory block can be updated according to the processing progress of the message, so that the state identifier truly reflects the state of the memory block, thereby improving the accuracy and reliability of the message cache.

In an actual application, the foregoing embodiments of the message header may be implemented separately or in combination, and the embodiment is not limited thereto. The first message and the second message are only used to distinguish messages obtained based on different implementation manners, and the “first” “second” does not specifically define the content of the message. It can be understood that the first message and the second message can be the same message.

It can be understood that the event can be determined to be processed only after the event corresponding to the event is processed, and the value of the bit corresponding to the event can be updated. Optionally, based on any of the foregoing embodiments, 1033 may include: if the number of the target messages is multiple, calling, for any target message, a task that supports the to-be-processed event, The target message is processed, and the processed target message is cleared; and the step of performing the acquiring the target message associated with the to-be-processed event is returned, until the number of the target message is 1, and the event supporting the pending event is invoked. Task, processing the target message, clearing the processed target message, and The bit corresponding to the processing event is set to the second value. Specifically, in the process of processing an event in the embodiment, if the event includes a message, each message of the event is processed in turn, and when the last message of the event is processed, in addition to the message In addition to the processing, the value of the bit corresponding to the event is also updated and set. In this implementation manner, in the process of processing the event, the bit value corresponding to the event is updated, the event state is updated in time, and the accuracy and reliability of the scheduling are improved.

The embedded scheduling method provided in this embodiment divides the message pool into multiple memory blocks. For an event including a message, the idle memory block can be searched for the event message, and then the event is processed from the memory block. Extracting corresponding messages for processing enables efficient and reliable management of event messages and effectively saves memory resources.

In practical applications, in order to avoid the situation of scheduling lockup, the processing of the event to be processed may also be processed by polling. Correspondingly, based on any of the preceding embodiments, the method may further include: if there are multiple to-be-processed events, and an event including multiple messages exists in the multiple to-be-processed events, the polling processing manner is adopted. In turn, each pending event is taken as the current processing object, and the task supporting the processing object is called, and the processing object is processed in a single process until the processing of all pending events is completed.

Wherein, the single processing can represent processing of a single target. For example, the calling supports the task of the processing object, and performing a single processing on the processing object may include: if the processing object includes a message, calling a task supporting the processing object to the processing object The single message is processed; if the processing object does not include a message, the task supporting the processing object is called, and the processing object is processed.

Specifically, in the message processing policy, if an event corresponds to multiple messages, the remaining messages are skipped after one message of the event is processed, and the next event is scheduled, and the remaining messages are waiting for subsequent scheduling. Polling, this can effectively prevent improper use of scheduling, and avoid scheduling locks, for example, locks caused by tasks sending messages to themselves.

It should be noted that the drawings are only an exemplary embodiment. In the foregoing method embodiments, the order of execution between the foregoing steps may not be limited to the case shown in the figure, as long as the logic does not conflict. For example, in step 1 and step 2, step 2 may be performed first, or step 2 may be performed first, or step 1 may be performed first, or step 1 and step 2 may be performed at the same time, which is not limited in this embodiment.

3A is a schematic structural diagram of an embedded scheduling system according to Embodiment 3 of the present application; as shown in FIG. 3A, the embodiment provides an embedded scheduling system, which is used to implement a lightweight, A scheduling scheme with low resource consumption. Specifically, the embedded scheduling system includes:

The query module 31 is configured to traverse the current value of the bit in the first integer corresponding to each task, where the task is in one-to-one correspondence with the first integer, and the bit in the first integer corresponding to the task is The events supported by the task correspond one-to-one;

The querying module 31 is further configured to determine, as the current pending event, an event corresponding to a bit whose current value is the first value among the first integers corresponding to the tasks.

The processing module 32 is configured to invoke a task that supports the to-be-processed event, and process the to-be-processed event.

In an actual application, the embedded scheduling system may be a medium storing related execution code, for example, a USB flash drive, etc.; or the embedded scheduling system may also be a physical device integrated or installed with related execution code, for example, a chip. , smart terminals, computers, etc.

In practical applications, different tasks support different events, that is, different tasks can handle different events. In this embodiment, each task is assigned a corresponding integer in advance, and corresponding bits are allocated for events supported by each task. Specifically, the different values of the bits corresponding to an event may indicate whether the event currently needs to be processed.

Based on the foregoing scenario, the system may further include: a first update module, configured to: if the processing of the to-be-processed event is completed, set a bit corresponding to the to-be-processed event to a second value. After the processing of the pending event is completed, the first update module may update the value of its corresponding bit to improve the accuracy and reliability of the subsequent scheduling.

Optionally, the system further includes: a second update module, configured to: if a new event is detected, set a value of a bit corresponding to the new event to the first value. The new event mentioned here is a newly generated event that needs to be processed. When there is a newly generated event that needs to be processed, the second update module sets the bit corresponding to the event to be processed to a corresponding value.

In order to further save the resources and space required for scheduling, an integer of the same number of bits can be allocated according to the number of events supported by the task. Correspondingly, as shown in FIG. 3B, on the basis of the third embodiment, the system further includes: an allocating module 33, configured to allocate a first integer for each task, and the number of bits of the first integer corresponding to the task The number of the events supported by the task is consistent; the allocating module 33 is further configured to allocate the bits of the first integer corresponding to the task to the any one-to-one correspondingly Supported events.

For example, in the actual scenario, the allocation module 33 assigns an integer to each task for all tasks that can be called currently, and the number of bits corresponding to each task is consistent with the number of events supported by the task. After the allocation module 33 assigns the corresponding integer, for each task, the allocation module 33 assigns the bits of the integer corresponding to the task to the event supported by the task in a one-to-one correspondence.

In an implementation manner, for an integer corresponding to each task, the integers may be generated by creating an integer array. Specifically, as shown in FIG. 3C, on the basis of Embodiment 3, the allocation module 33 includes: a first creating unit 331, configured to establish, according to the number of the tasks, a one-dimensional integer array including a plurality of first integers, the number of the plurality of first integers being consistent with the number of the tasks; The unit 332 is configured to allocate the first integers in the one-dimensional integer array to the tasks in a one-to-one correspondence.

Specifically, the first creating unit 331 creates a corresponding one-dimensional array according to the number of currently available tasks, and the first allocating unit 332 allocates the integers in the array to each task according to a one-to-one correspondence principle. The allocation module 33 then assigns the bits of its corresponding integers to the tasks supported by the task in a one-to-one correspondence for each task. In this embodiment, an integer corresponding to each task is generated by establishing a one-dimensional array, thereby reducing processing consumption and time consumption, and improving scheduling efficiency, so that the scheduling scheme is better. Applicable to devices with limited hardware resources.

Optionally, after determining the pending event to be processed, the characteristics of the bit order can be introduced into the priority control between events. Correspondingly, as shown in FIG. 3D, on the basis of Embodiment 3, the system further includes: an event priority module 34, configured to determine a priority of each event; and an allocation module 33, specifically configured to perform bit order and events. The principle of consistent priority allocation allocates the bits of the first integer corresponding to the task in a one-to-one correspondence to the events supported by the task.

In the actual scheduling process, in order to improve the scheduling effect and user experience, the processing priority of each event may be different. In this embodiment, the event priority module 34 first determines the priority of each event, and after determining the priority, in combination with the foregoing embodiment, the allocation module 33 considers the bit order and the priority of each event while allocating bits for each event. Level, assigning corresponding bits to each event according to the principle of consistent non-allocation of bit order and time. The agreement here includes the same or the opposite.

Optionally, based on the foregoing event allocation scheme, it is assumed that the allocation is performed according to the principle that the bit order and the priority of the event are the same, and then the event processing is performed later, and the basis of the embodiment shown in FIG. 3D is performed. The processing module 32 is specifically configured to: in response to the bit sequence of the bit corresponding to the to-be-processed event, sequentially, for each pending event, invoke a task that supports the to-be-processed event, and process the to-be-processed event. . In this embodiment, by combining the characteristics of the bit order and the priority of the event in the process of allocating the bit for the event, the subsequent event processing in the bit order simply and skillfully utilizes the characteristics of the bit sequence to implement event processing. Priority control, which further saves resources required for scheduling.

Specifically, each task in the solution includes a task that can be invoked by the current scheduling system. In practical applications, if a call to a task needs to be implemented, the task needs to be registered in the scheduling system in advance. Correspondingly, based on the third embodiment, the system further includes: a receiving module, configured to receive a registration request, the registration request includes a task processing function of the task; and a registration module, configured to perform, according to the task processing function, The task performs function registration.

The embedded scheduling system provided in this embodiment allocates corresponding bits for the event by assigning corresponding integers to the task, and designates the value of the bit corresponding to the event as a single bit value that does not interfere with each other, and the value of the bit is used. In the process of task scheduling, the current pending event can be quickly and accurately determined by traversing the value of the bit in the integer corresponding to the task, and then calling The corresponding task processes the pending event. The scheme adopts the event-driven task scheduling method, so that all events of the task can be cached by integers, and realize a good use effect, and realize a lightweight and low resource consumption scheduling scheme, which can be effectively applied to hardware resource shortage. Equipment, and the solution is easy to implement, resource consumption is low, and startup is fast. In practical applications, the above solution can be used for scheduling common tasks as well as for calling deep hierarchical systems and reducing system coupling.

In practice, a message pool can be used to cache various messages. Correspondingly, as shown in FIG. 4A, FIG. 4A is a schematic structural diagram of an embedded scheduling system according to Embodiment 4 of the present application. On the basis of Embodiment 3, the embedded scheduling system further includes: a cache module 41, If a new event is detected and the new event includes a message, the message is cached to the message pool.

Specifically, if the detected new event includes a message, the message is cached in the message pool, and when the event is processed, the message is obtained from the message pool, and the message is processed. Complete the processing of the event. Correspondingly, as shown in FIG. 4B, on the basis of the embodiment shown in FIG. 4A, the processing module 32 includes: a message obtaining unit 321 for acquiring a target message associated with the to-be-processed event; and a message processing unit 322, The target message is processed and the processed target message is cleared by invoking a task supporting the pending event. In this embodiment, for an event including a message, the processing of the event is completed by processing the message, and the processed message is cleared, thereby effectively saving the memory occupied by the message cache on the basis of implementing the event processing.

As shown in FIG. 4C, the system further includes: a dividing module 42 for dividing the memory in the message pool according to a preset partitioning granularity, as shown in FIG. 4C. Obtaining a plurality of memory blocks; the cache module 41 is configured to: if a new event is detected and the new event includes a message, find a free target memory block from the plurality of memory blocks, and cache the message to The target memory block.

Wherein, the division granularity can be set according to needs or experience. The dividing module 42 divides the message pool into a plurality of memory blocks, and implements distributed management of the memory of the message pool. The cache module 41 searches for a free target memory block from the plurality of memory blocks when the message is cached, and caches the message to the target memory block. In this implementation manner, the message pool is divided into multiple memory blocks to implement distributed management. If the detected new event includes a message, when the message needs to be cached, the free memory block is searched from the plurality of memory blocks. The message of the new event is cached into the found memory block, which improves the efficiency of the message cache and saves resource consumption.

Optionally, in order to find the free memory block more quickly and accurately, as shown in FIG. 4D, on the basis of the embodiment shown in FIG. 4C, the system further includes: an identification module 43 for each memory. The block sets a status identifier, and the status identifier of the memory block is used to characterize whether the memory block is free. Specifically, after the dividing module 42 divides the message pool into a plurality of memory blocks, the identifying module 43 sets a status identifier for each memory block. When the cache module 41 needs to find an idle memory block, it only needs to traverse the status of each memory block. The identification can quickly and accurately determine the free memory block, improving the efficiency of the message cache.

Among them, the status identifier can be in various forms. Optionally, in order to further reduce resource consumption, on the basis of the embodiment shown in FIG. 4D, the identifier module 43 includes:

a second creating unit, configured to create a second integer, where the number of bits of the second integer is consistent with the number of the plurality of memory blocks;

a second allocation unit, configured to allocate the bits of the second integer to the inner one-to-one correspondence a storage block, wherein a status of the memory block is identified as a bit corresponding to the memory block, and different values of the corresponding bit of the memory block respectively indicate that the memory block is idle or not idle.

Specifically, after the dividing module 42 divides the message pool into a plurality of memory blocks, the second creating unit creates a second integer whose number of bits is consistent with the number of the memory blocks according to the number of the memory blocks, and the second allocating unit according to the one-to-one correspondence The allocation principle assigns the bits of the second integer to the memory block.

Based on the above status identifier, when the message of the event needs to be cached, the free memory block can be quickly found. Specifically, the cache module may specifically include: a searching unit, configured to: if a new event is detected and the new event includes a message, traverse the state identifiers of the plurality of memory blocks to find out The status is identified as an idle target memory block; a storage unit is configured to cache the message to the target memory block and set the status identifier of the target memory block to be non-idle. In this embodiment, if a new event is detected, including a message, the idle memory block is quickly determined to perform message buffering based on the status identifier of each memory block, and the status identifier of the memory block is updated, thereby improving the efficiency and accuracy of the message cache. .

Specifically, in the process of finding a free memory block for message buffering, the number of memory blocks occupied by the message may be different according to the data size of the message. Correspondingly, on the basis of the fourth embodiment, the storage unit is specifically used for If the data volume of the message is not greater than the storage capacity of the single target memory block, the message is cached to the target memory block; the storage unit is further configured to: if the data volume of the message is greater than a single target memory The storage capacity of the block splits the message into a plurality of message blocks and caches the plurality of message blocks to a plurality of target memory blocks, respectively. In this manner, messages of different sizes can be cached to improve the reliability of the message cache.

In an actual application, in order to obtain a corresponding message when the event processing is performed, the system further includes: a generating module, configured to generate a message header of the message, where the message header includes the message, The message acquiring unit 321 includes: a processing subunit, configured to determine a target message associated with the to-be-processed event; and an extracting subunit, configured to acquire the target message from a message header of the target message The information of the memory block is located, and the message cached in the memory block where the target message is located is extracted as the target message. In this implementation manner, the message block in which the message is located is accurately and simply represented by generating a message header of the message, thereby accurately and quickly determining the cache of the message. Location to improve the efficiency of subsequent message processing.

Further, in order to be able to determine the message corresponding to the event to be processed, in an implementation manner, on the basis of the foregoing implementation manner, the message header of the message further includes information about an event to which the message belongs; the processing subunit Specifically, the first message is determined to be the target message, and the message header of the first message includes information about the to-be-processed event. In this embodiment, by generating a message header of the message, the corresponding relationship between the event and the message is accurately and simply characterized, and the cache location of the message can be accurately and quickly determined, thereby improving the efficiency of subsequent message processing.

Optionally, in another implementation manner, the message header of the message further includes information that supports a task to which the message belongs, and the processing sub-unit is specifically used. The second message is determined to be the target message, and the message header of the second message includes information of a task supporting the to-be-processed event. In this embodiment, by generating a message header of the message, the corresponding relationship between the event and the message is accurately and simply characterized, and the cache location of the message can be accurately and quickly determined, thereby improving the efficiency of subsequent message processing.

Further, if an event includes multiple messages, the priority processing mechanism of the message may be introduced. Optionally, the message header of the message further includes message counting information, where the message processing unit 322 is specifically configured to sequentially follow the order of the counting information corresponding to the target message. The target information, the task supporting the to-be-processed event is invoked, the target message is processed, and the processed target message is cleared. In this embodiment, by adding message count information to the message header of the message, the priority of the message processing is introduced, and the priority mechanism of the message processing is implemented simply and effectively.

Further, on the basis of any of the foregoing embodiments, after clearing the processed target message, the status identifier of the memory block where the processed target message is located may also be set to idle. Correspondingly, the system further includes: a third update module, configured to set a status identifier of the memory block where the processed target message is located to be idle. According to the embodiment, the state identifier of the memory block can be updated according to the processing progress of the message, so that the state identifier truly reflects the state of the memory block, thereby improving the accuracy and reliability of the message cache.

It can be understood that the event can be determined to be processed only after the event corresponding to the event is processed, and the value of the bit corresponding to the event can be updated. Optionally, on the basis of any of the preceding embodiments, the message processing unit 322 is specifically configured to: if the number of the target messages is multiple, invoke a task that supports the to-be-processed event for any target message, For the stated The target message is processed, and the processed target message is cleared. The message processing unit 322 is further configured to perform the step of acquiring the target message associated with the to-be-processed event again, until the number of the target message is 1. Then, the task supporting the to-be-processed event is invoked, the target message is processed, the processed target message is cleared, and the bit corresponding to the to-be-processed event is set to a second value. In this implementation manner, in the process of processing the event, the bit value corresponding to the event is updated, the event state is updated in time, and the accuracy and reliability of the scheduling are improved.

The embedded scheduling system provided in this embodiment divides the message pool into multiple memory blocks. For events including messages, the idle memory block can be searched for the event message, and the event is processed from the memory block. Extracting corresponding messages for processing enables efficient and reliable management of event messages and effectively saves memory resources.

In practical applications, in order to avoid the situation of scheduling lockup, the processing of the event to be processed may also be processed by polling. Correspondingly, on the basis of any of the foregoing embodiments, the processing module 32 is specifically configured to: if there are multiple to-be-processed events, and an event including multiple messages exists in the multiple to-be-processed events, polling is used. The processing mode sequentially takes each to-be-processed event as a current processing object, calls a task that supports the processing object, and performs a single processing on the processing object until the processing of all pending events is completed.

Wherein, the single processing can represent processing of a single target. For example, the processing module 32 is specifically configured to: if there are multiple to-be-processed events, and an event that includes multiple messages exists in the multiple to-be-processed events, use a polling processing manner to sequentially process each to be processed. The event is the current processing object. If the processing object includes a message, the task supporting the processing object is called to process a single message of the processing object until the processing of all pending events is completed; the processing module 32 further Specifically, if there are multiple to-be-processed events, and an event including multiple messages exists in the multiple to-be-processed events, the polling processing mode is adopted, and each pending event is sequentially used as a current processing object. If the processing object does not include a message, the task supporting the processing object is invoked, and the processing object is processed until the processing of all pending events is completed. In the message processing strategy, if an event corresponds to multiple messages, the remaining messages are skipped after one message of the event is processed, and the next event is scheduled, and the remaining messages are waiting for subsequent scheduling polling. This can effectively prevent improper use of scheduling, and avoid scheduling locks, for example, locks caused by tasks sending messages to themselves.

FIG. 5 is a schematic structural diagram of an embedded scheduling system according to Embodiment 5 of the present invention. As shown in FIG. 5, the system includes: a scheduler, an event management module, and a message management module.

The event management module is mainly responsible for caching events, for example, the event may be an event received from an external event source or an event triggered during event processing; the message management module includes a message header module and a message pool, and message management The module is mainly responsible for the buffering of messages, and the scheduler is mainly responsible for the scheduling of events and messages. The list in the event management module represents a one-dimensional array storing integers corresponding to each task. Each unit in the list represents a single integer, and each integer corresponds to a task. The bits in the integer correspond to the events supported by the task. correspond. The message management module stores a message header of each message, and the message pool is used to cache each message.

Specifically, the scheduler performs scheduling processing by referring to the scheduling scheme based on the events and messages cached in the event management module and the message management module. Specifically, the scheduling scheme performed by the scheduler may refer to related content in the foregoing method embodiments, and details are not described herein again.

The embedded scheduling system provided in this embodiment adopts an event-driven task scheduling manner, so that all events of the task can be buffered by integers, and a lightweight and low resource consumption scheduling scheme can be implemented, which can be effectively applied to devices with insufficient hardware resources. And the solution is easy to implement, resource consumption is low, and startup is fast. In practical applications, the above embedded scheduling scheme can be used for scheduling common tasks as well as for calling deep hierarchical systems, and can reduce system coupling.

The sixth embodiment of the present application further provides a computer storage medium, which may include: a USB flash drive, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), and a RAM (Random Access Memory). A medium for storing a program code, such as a magnetic disk or an optical disk. Specifically, the computer storage medium stores program instructions, and the program instructions are used in the embedded scheduling method in the above embodiment.

Embodiment 7 of the present application provides an embedded scheduling system, which may be a terminal device installed with a program running system, such as a mobile phone, a computer, a PAD, or a smart watch, etc., the embedded scheduling system includes at least one processor And a memory for storing computer execution instructions, the number of processors may be one or more, and may work separately or in cooperation, and the processor is configured to execute the computer-executed instructions of the memory storage to implement the above embodiment. Embedded scheduling method.

The technical solutions and the technical features in the above various embodiments may be used in the case of the present invention without departing from the scope of the present invention.

Claims

An embedded scheduling method, comprising:

Traversing the current value of the bit in the first integer corresponding to each task, the task is in one-to-one correspondence with the first integer, and the bit in the first integer corresponding to the task and the event supported by the task are one by one correspond;

And determining, by the first integer corresponding to each task, an event corresponding to a bit whose current value is the first value as a current pending event;

Calling a task that supports the to-be-processed event, and processing the to-be-processed event.
The method of claim 1 further comprising:

Assigning a first integer to each task, the number of bits of the first integer corresponding to the task is consistent with the number of events supported by the task;

Assigning the bits of the first integer corresponding to the task to the event supported by the task in a one-to-one correspondence.
The method according to claim 2, wherein the assigning the bits of the first integer corresponding to the task to the event supported by the task in a one-to-one correspondence comprises:

Determine the priority of each event;

And allocating the bits of the first integer corresponding to the task to the events supported by the task in a one-to-one correspondence, including:

The bits of the first integer corresponding to the task are assigned to the event supported by the task in a one-to-one correspondence according to the allocation principle of the bit order and the priority of the event.
The method according to claim 3, wherein the invoking a task that supports the to-be-processed event, and processing the to-be-processed event comprises:

The task supporting the to-be-processed event is invoked for each pending event according to the bit sequence of the bit corresponding to the to-be-processed event, and the to-be-processed event is processed.
The method according to any one of claims 2 to 4, wherein the assigning a first integer to each task comprises:

Establishing, according to the number of the tasks, a one-dimensional integer array including a plurality of first integers, the number of the plurality of first integers being consistent with the number of the tasks;

The first integers in the one-dimensional integer array are assigned to the tasks in a one-to-one correspondence.
The method according to any one of claims 1 to 5, wherein the method further comprises:

If the processing of the to-be-processed event is completed, the bit corresponding to the to-be-processed event is set to a second value.
The method according to any one of claims 1 to 6, wherein the method further comprises:

If a new event is detected, the value of the bit corresponding to the new event is set to the first value.
The method of any of claims 1-7, wherein the method further comprises:

If a new event is detected and the new event includes a message, the message is cached to the message pool.
The method according to claim 8, wherein the invoking a task that supports the to-be-processed event, and processing the to-be-processed event comprises:

Obtaining a target message associated with the pending event;

Calling a task that supports the pending event, processing the target message, and clearing the processed target message.
The method according to claim 8 or 9, wherein the method further comprises:

Divide the memory in the message pool according to the preset granularity to obtain multiple memory blocks;

If the new event is detected and the new event includes a message, the message is cached to the message pool, including:

If a new event is detected and the new event includes a message, an idle target memory block is found from the plurality of memory blocks and the message is cached to the target memory block.
The method of claim 10, wherein the method further comprises:

A status identifier is set for each memory block, and the status identifier of the memory block is used to characterize whether the memory block is free.
The method according to claim 11, wherein said setting a status identifier for each memory block comprises:

Creating a second integer, the number of bits of the second integer being consistent with the number of the plurality of memory blocks;

Allocating the bits of the second integer to the memory block in a one-to-one correspondence, wherein a state identifier of the memory block is a bit corresponding to the memory block, and a different value of a bit corresponding to the memory block The memory blocks are characterized as being idle or not, respectively.
The method according to claim 11 or 12, wherein if the new event is detected and the new event includes a message, the free target memory block is searched from the plurality of memory blocks, and the The message is cached to the target memory block, including:

If a new event is detected and the new event includes a message, traversing the status identifiers of the plurality of memory blocks to find a target memory block whose status is identified as idle;

The message is cached to the target memory block and the status identifier of the target memory block is set to be non-idle.
The method according to any one of claims 10 to 13, wherein the buffering the message to the target memory block comprises:

If the data amount of the message is not greater than the storage capacity of the single target memory block, buffering the message to the target memory block;

If the data amount of the message is greater than the storage capacity of the single target memory block, the message is split into a plurality of message blocks, and the plurality of message blocks are separately cached to a plurality of target memory blocks.
The method of any of claims 10-14, wherein the method further comprises:

Generating a message header of the message, where the message header includes information of a memory block in which the message is located;

And obtaining the target message associated with the to-be-processed event, including:

Determining a target message associated with the pending event;

Acquiring information of a memory block in which the target message is located from a message header of the target message, and extracting a message cached in a memory block where the target message is located as the target message.
The method according to claim 15, wherein the message header of the message further includes information about an event to which the message belongs; and the determining the target message associated with the to-be-processed event includes:

Determining that the first message is the target message, and the message header of the first message includes information of the to-be-processed event.
The method according to claim 15 or 16, wherein the message header of the message further comprises information of a task supporting an event to which the message belongs; and the determining the target message associated with the to-be-processed event comprises:

Determining that the second message is the target message, and the message header of the second message includes supporting the Information about the task that handles the event.
The method according to any one of claims 15-17, wherein the message header of the message further comprises message counting information; the calling supports a task of the to-be-processed event, and processing the target message And clear the processed target message, including:

And according to the order of the counting information corresponding to the target message, sequentially, for each target information, a task supporting the to-be-processed event is invoked, the target message is processed, and the processed target message is cleared.
The method according to any one of claims 11 to 18, wherein after the clearing the processed target message, the method further comprises:

Set the status ID of the memory block where the processed target message is located to idle.
The method according to any one of claims 9 to 19, wherein the invoking a task supporting the event to be processed, processing the target message, and clearing the processed target message comprises:

If the number of the target messages is multiple, the task supporting the to-be-processed event is invoked for any target message, the target message is processed, and the processed target message is cleared;

Returning to the step of performing the acquiring the target message associated with the to-be-processed event, until the number of the target message is 1, calling a task supporting the to-be-processed event, processing the target message, and clearing the processed a target message, and setting a bit corresponding to the to-be-processed event to a second value.
The method according to any one of claims 1 to 20, wherein the invoking a task that supports the to-be-processed event, and processing the to-be-processed event comprises:

If there are multiple to-be-processed events, and an event including multiple messages exists in the plurality of to-be-processed events, the polling processing mode is adopted, and each to-be-processed event is sequentially used as a current processing object, and the support is invoked. The task of the object is processed, and the processing object is processed in a single process until the processing of all pending events is completed.
The method according to claim 21, wherein the invoking a task supporting the processing object, and performing a single processing on the processing object comprises:

If the processing object includes a message, calling a task that supports the processing object to process a single message of the processing object;

If the processing object does not include a message, calling a task that supports the processing object, Process objects for processing.
The method of any of claims 1 to 22, wherein the method further comprises:

Receiving a registration request, the registration request including a task processing function of the task;

A function registration is performed on the task according to the task processing function.
An embedded scheduling system, comprising:

a query module, configured to traverse a current value of a bit in a first integer corresponding to each task, where the task is in one-to-one correspondence with the first integer, and a bit in the first integer corresponding to the task is related to the task Supported events correspond one-to-one;

The querying module is further configured to determine, as the current pending event, an event corresponding to a bit whose current value is the first value in the first integer corresponding to each task;

And a processing module, configured to invoke a task that supports the to-be-processed event, and process the to-be-processed event.
The system of claim 24, wherein the system further comprises:

An allocating module, configured to allocate a first integer to each task, where the number of bits of the first integer corresponding to the task is consistent with the number of events supported by the task;

The allocating module is further configured to allocate the bits of the first integer corresponding to the task to the event supported by the task in a one-to-one correspondence.
The system of claim 25, wherein the system further comprises:

An event priority module for determining the priority of each event;

The allocating module is specifically configured to allocate the bits of the first integer corresponding to the task to the event supported by the task in a one-to-one correspondence according to the allocation principle of the bit order and the priority of the event.
The system of claim 26 wherein:

The processing module is configured to: in response to the bit sequence of the bit corresponding to the to-be-processed event, sequentially, for each pending event, invoke a task that supports the to-be-processed event, and process the to-be-processed event.
The system of any of claims 25-27, wherein the distribution module comprises:

a first creating unit, configured to establish, according to the number of the tasks, a plurality of first integers a one-dimensional array of integers, the number of the plurality of first integers being consistent with the number of the tasks;

And a first allocation unit, configured to allocate the first integers in the one-dimensional integer array to the tasks in a one-to-one correspondence.
A system according to any one of claims 24 to 28, wherein the system further comprises:

And a first update module, configured to set a bit corresponding to the to-be-processed event to a second value, if the processing of the to-be-processed event is completed.
A system according to any one of claims 24 to 29, wherein the system further comprises:

And a second update module, configured to: if a new event is detected, set a value of a bit corresponding to the new event to the first value.
A system according to any one of claims 24 to 30, wherein the system further comprises:

a caching module, configured to cache the message to a message pool if a new event is detected and the new event includes a message.
The system of claim 31, wherein the processing module comprises:

a message obtaining unit, configured to acquire a target message associated with the to-be-processed event;

a message processing unit, configured to invoke a task that supports the to-be-processed event, process the target message, and clear the processed target message.
The system of claim 31 or 32, wherein the system further comprises:

a dividing module, configured to divide a memory in a message pool according to a preset granularity, and obtain a plurality of memory blocks;

The cache module is configured to: if a new event is detected and the new event includes a message, find a free target memory block from the plurality of memory blocks, and cache the message to the target memory block .
The system of claim 33, wherein the system further comprises:

And an identifier module, configured to set a status identifier for each memory block, where the status identifier of the memory block is used to indicate whether the memory block is idle.
The system of claim 34, wherein the identification module comprises:

a second creating unit, configured to create a second integer, the number of bits of the second integer is the same as The number of multiple memory blocks is the same;

a second allocation unit, configured to allocate the bits of the second integer to the memory block in a one-to-one correspondence, wherein a state identifier of the memory block is a bit corresponding to the memory block, and the memory block corresponds to The different values of the bits respectively indicate that the memory block is idle or not idle.
The system according to claim 34 or 35, wherein the cache module comprises:

a searching unit, configured to: if a new event is detected, and the new event includes a message, traverse the state identifiers of the plurality of memory blocks, and find a target memory block whose status identifier is idle;

a storage unit, configured to cache the message to the target memory block, and set a status identifier of the target memory block to be non-idle.
A system according to any one of claims 33 to 36, wherein

The storage unit is specifically configured to cache the message to the target memory block if the data volume of the message is not greater than a storage capacity of a single target memory block;

The storage unit is further configured to: if the data volume of the message is greater than a storage capacity of a single target memory block, split the message into multiple message blocks, and cache the multiple message blocks to multiple Target memory block.
The system of any of claims 33-37, wherein the system further comprises:

a generating module, configured to generate a message header of the message, where the message header includes information about a memory block where the message is located;

The message obtaining unit includes:

a processing subunit, configured to determine a target message associated with the to-be-processed event;

And an extracting subunit, configured to acquire information about a memory block in which the target message is located from a message header of the target message, and extract a message buffered in a memory block where the target message is located as the target message.
The system according to claim 38, wherein the message header of the message further includes information of an event to which the message belongs;

The processing sub-unit is specifically configured to determine that the first message is the target message, and the message header of the first message includes information about the to-be-processed event.
The system according to claim 38 or 39, wherein the message header of the message further comprises information supporting a task to which the message belongs;

The processing sub-unit is specifically configured to determine that the second message is the target message, and the message header of the second message includes information that supports the task of the to-be-processed event.
A system according to any one of claims 38 to 40, wherein the message header of the message further comprises message count information;

The message processing unit is configured to: in response to the order of the counting information corresponding to the target message, sequentially, for each target information, invoke a task that supports the to-be-processed event, process the target message, and clear the processed Target message.
The system of any of claims 34-41, wherein the system further comprises:

And a third update module, configured to set a status identifier of the memory block where the processed target message is located to be idle.
A system according to any of claims 32-42, wherein

The message processing unit is specifically configured to: if the number of the target messages is multiple, invoke a task that supports the to-be-processed event for any target message, process the target message, and clear the processed message. Target message

The message processing unit is further configured to perform the step of acquiring the target message associated with the to-be-processed event again, until the number of the target message is 1, and the task supporting the to-be-processed event is invoked, The target message is processed, the processed target message is cleared, and the bit corresponding to the to-be-processed event is set to a second value.
A system according to any one of claims 24 to 43 wherein:

The processing module is specifically configured to: if there are multiple to-be-processed events, and an event that includes multiple messages exists in the multiple to-be-processed events, use a polling processing manner to sequentially treat each pending event as a current The processing object calls a task that supports the processing object, and performs a single processing on the processing object until the processing of all pending events is completed.
The system of claim 44, wherein

The processing module is specifically configured to: if there are multiple to-be-processed events, and an event that includes multiple messages exists in the multiple to-be-processed events, use a polling processing manner to sequentially treat each pending event as a current a processing object, if the processing object includes a message, calling a task supporting the processing object to process a single message of the processing object until the processing of all pending events is completed;

The processing module is further configured to: if there are multiple to-be-processed events, and an event that includes multiple messages exists in the multiple to-be-processed events, use a polling processing manner to sequentially treat each pending event as The current processing object, if the processing object does not include a message, invokes a task that supports the processing object, and processes the processing object until the processing of all pending events is completed.
A system according to any one of claims 24 to 45, wherein the system further comprises:

a receiving module, configured to receive a registration request, where the registration request includes a task processing function of the task;

a registration module, configured to perform function registration on the task according to the task processing function.
An embedded scheduling system, comprising: at least one processor and a memory;

The memory storage computer executes instructions; the at least one processor executes the computer-executed instructions stored by the memory to perform the method of any of claims 1-23.
A computer storage medium, characterized in that the computer storage medium stores program instructions, the program instructions being executed by a processor to implement the method of any one of claims 1-23.