An Optimization Method for Integrated Circuit Applications Based on Edge Computing

By dynamically adjusting task priorities and resource allocation, the problem of task processing latency when integrated circuit computing resources are limited in edge computing environments is solved, achieving efficient task scheduling and real-time response capabilities, which are applicable to scenarios such as smart manufacturing production lines, industrial IoT gateways, and autonomous driving domain controllers.

CN123114769APending Publication Date: 2026-11-17SHANDONG LIGUO TECHNOLOGY CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611430675.9
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-09-15
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

In the current edge computing environment, when integrated circuit computing resources are limited and task concurrency continues to rise, the scheduling strategy for multi-path heterogeneous data stream processing tasks cannot be dynamically adjusted, resulting in delays in the processing of critical time-sensitive tasks and insufficient real-time response capabilities.

Method used

By acquiring the timing characteristics and source identifiers of multiple data streams, the burst state and task criticality level of the data streams can be determined, the task priority can be dynamically adjusted, and when the capacity of the dedicated processing core is insufficient, the tasks on the shared processing core can be suspended to release computing resources and the instruction queue of the integrated circuit can be adjusted to prioritize the execution of high-urgent tasks.

Benefits of technology

It achieves coordinated optimization of task scheduling accuracy and system throughput under the constraints of integrated circuit computing resources, and can adaptively track changes in data flow rhythm and system load fluctuations, thereby improving the real-time response capability of edge nodes.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123114769A_ABST
    Figure CN123114769A_ABST
Patent Text Reader

Abstract

This invention provides an optimization method for integrated circuit applications based on edge computing, relating to the fields of edge computing and integrated circuit task scheduling technology. It identifies burst arrival patterns of data streams by performing time-series feature analysis on multiple data streams and maps changes in the arrival rhythm of the data stream physical layer to the task scheduling domain in real time. This allows task priorities to simultaneously respond to external data stream bursts and internal deadline urgency, avoiding scheduling imbalances caused by single-dimensional decision-making. Furthermore, this invention dynamically allocates dedicated and shared processing cores based on task priorities and selectively suspends high-slack tasks that meet safety conditions to release computing resources when core capacity is insufficient. Simultaneously, it introduces hysteresis boundaries based on migration overhead during task migration to prevent frequent round-trip migrations between cores, effectively reducing computing power loss caused by context switching.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the fields of edge computing and integrated circuit task scheduling technology, and more specifically, to an optimization method for integrated circuit applications based on edge computing. Background Technology

[0002] With the large-scale deployment of applications such as smart manufacturing, industrial IoT, and real-time data analytics, edge computing, as a new computing paradigm that moves computing tasks from the cloud to the network edge, is increasingly becoming a key technology for alleviating cloud center computing power bottlenecks and reducing end-to-end response latency. In real-time sensitive application environments such as smart manufacturing production lines, autonomous driving, and industrial vision inspection, edge nodes typically use multi-core heterogeneous integrated circuits (such as multi-processor systems-on-a-chip, field-programmable gate arrays, application-specific integrated circuits, and embedded graphics processors) as computing power carriers, and need to simultaneously process high-frequency data streams from multiple heterogeneous sensors, including those for temperature, pressure, vibration, vision, servo drives, and safety interlocks. These data streams exhibit significant dynamic differences and heterogeneous characteristics in terms of arrival frequency, data packet capacity, time limits, and criticality levels. Therefore, how to achieve efficient scheduling and dynamic optimization allocation of computing resources for processing tasks corresponding to multiple data streams under the conditions of limited integrated circuit computing resources and continuously increasing task concurrency has become one of the core technical problems that urgently need to be solved in the field of edge computing.

[0003] Existing task scheduling methods in edge computing environments can be mainly categorized into static priority scheduling (such as monotonic rate scheduling), earliest deadline first scheduling, and reinforcement learning-based adaptive scheduling. Static priority scheduling allocates computing resources based on task type or a fixed period, making it difficult to respond to dynamic changes in the arrival rhythm of data streams. While earliest deadline first scheduling can sort tasks according to their deadlines, this type of method only focuses on the internal time attributes of tasks, ignoring the instantaneous impact of external data stream arrival characteristics on system load. When multiple heterogeneous data streams arrive concurrently, low-priority tasks may continuously occupy processing cores, leading to delays in high-time-sensitive tasks. In recent years, while deep reinforcement learning-based scheduling methods have achieved dynamic adjustment of task priorities to some extent, they rely on a large number of offline training samples and online inference overhead. When deployed on resource-constrained edge integrated circuits, they face practical constraints such as excessive computing power, slow convergence speed, and insufficient real-time guarantees. Furthermore, most existing scheduling frameworks for heterogeneous multi-core platforms presuppose that tasks have fixed execution modes or homogeneous model sets, failing to fully consider the coupling relationship between fine-grained data flow rhythm changes and computing resource competition during runtime, and lacking a flexible scheduling mechanism that can dynamically rearrange the integrated circuit execution queue at the instruction or task level. Summary of the Invention

[0004] To address the aforementioned technical problems, this invention provides an optimization method for integrated circuit applications based on edge computing. This method addresses, to some extent, the problem that existing edge computing nodes fail to dynamically adjust execution priorities based on task timeliness and data characteristics in their computing power allocation strategies. When multiple heterogeneous data arrive concurrently, critical time-sensitive tasks experience processing delays due to low-priority tasks occupying computing resources, resulting in insufficient real-time response capabilities of integrated circuits at the edge.

[0005] According to one aspect of the present invention, an integrated circuit application optimization method based on edge computing is provided, comprising:

[0006] Obtain the temporal characteristics and source identifiers of multiple data streams to determine the burst state of the data streams and the criticality level of the corresponding tasks;

[0007] The task priority is determined based on the task's time limit information and computing power usage information, and the task priority is adjusted according to the aforementioned emergency status and criticality level.

[0008] Based on the adjusted task priority, tasks are assigned to dedicated processing cores, and when the capacity of dedicated processing cores is insufficient, suspendable tasks on shared processing cores are suspended to free up computing resources.

[0009] Adjust the instruction queue of the integrated circuit according to the computing power resource allocation results, and execute each task according to the adjusted task priority.

[0010] Furthermore, determining the burst state of the data stream includes:

[0011] Data streams are categorized into periodic streams and event streams.

[0012] For periodic flows, the ratio of the variance of the arrival interval within the current sliding time window to the variance of the stable operating baseline is calculated as the variance multiple relationship. A dynamic judgment boundary is constructed based on the stable sample set. When the variance multiple relationship exceeds the dynamic judgment boundary, it is judged as a sudden state.

[0013] For event-driven streams, the initial burst level is determined based on the event type and gradually decreases over time;

[0014] The dynamic determination boundary Determined by the following formula:

[0015]

[0016] in, For a stable window of samples, To ensure a stable and concentrated trend, This represents the median absolute deviation.

[0017] Furthermore, the gradual decay of the event-type stream over time includes:

[0018] The burstiness of a one-off event stream decays linearly to zero over time according to the following formula:

[0019]

[0020] in, The initial level of suddenness corresponding to the event type. The time of the most recent valid event. For the current moment, The decay duration corresponding to the event type.

[0021] Furthermore, adjusting the task priority includes:

[0022] When the data stream is in a burst state and the corresponding task is of high criticality, the timeliness slack, which is composed of the ratio of remaining tolerable latency to historical computing power occupancy time, is exponentially decayed based on the degree of burstiness and the task criticality coefficient, and the lower limit of decay is dynamically determined according to the minimum service requirements of the current shared task set.

[0023] Furthermore, the assignment of tasks to dedicated processing cores includes:

[0024] The entry boundary for entering the dedicated processing core and the exit boundary for exiting the dedicated processing core are determined based on the task priority index and migration overhead ratio.

[0025] The migration overhead ratio is determined by the ratio of the sum of context save time, context restore time, and queue switching time to the historical computing power usage time.

[0026] The entry boundary is 1 minus the migration cost ratio, the exit boundary is 1 plus the migration cost ratio, the entry boundary is lower than the exit boundary, and a hysteresis region is formed between the two.

[0027] When the task priority index is within the lag zone, the current core ownership remains unchanged. The migration from the shared processing core to the dedicated processing core is triggered only when the task priority index drops to the entry boundary. The release from the dedicated processing core to the shared processing core is triggered only when the task priority index rises to the exit boundary.

[0028] Furthermore, the migration overhead ratio Determine as follows:

[0029]

[0030] in, Save the time for the context of task i. For context recovery time, For queue switching time, Historical computing power usage time For numerically stable terms, and These represent the lower and upper bounds of the migration cost ratio, respectively.

[0031] Furthermore, the suspendable tasks on the suspended shared processing core include:

[0032] Traverse the tasks that are running on the shared processing core and meet the suspension candidate conditions, wherein the candidate conditions are that the priority of the task is lower than the exit boundary and the task is in a ready state.

[0033] Detect whether each candidate task holds cross-core shared resources and whether it is in a safe suspended position;

[0034] Prioritize suspending tasks that do not hold cross-core shared resources and are in a safe suspension position;

[0035] If a candidate task still holds cross-core shared resources or is not in a safe suspended position, skip the task and continue to check the next candidate task.

[0036] According to another aspect of the present invention, an integrated circuit application optimization system based on edge computing is provided, comprising:

[0037] The data stream feature extraction module is used to obtain the temporal characteristics and source identifiers of multiple data streams, and to determine the burst state of the data streams and the criticality level of the corresponding tasks.

[0038] The task priority calculation module is used to determine the task priority based on the task's time limit information and computing power usage information, and to adjust the task priority according to the aforementioned emergency status and criticality level.

[0039] The computing resource management module is used to allocate tasks to dedicated processing cores according to the adjusted task priorities, and to suspend suspendable tasks on shared processing cores to release computing resources when the capacity of dedicated processing cores is insufficient.

[0040] The instruction scheduling module is used to adjust the instruction queue of the integrated circuit according to the computing power resource allocation results, and execute each task according to the adjusted task priority.

[0041] Compared with existing technologies, the edge computing-based integrated circuit application optimization method provided by this invention identifies the burst arrival patterns of data streams by performing time-series feature analysis on multiple data streams and maps the arrival rhythm changes of the data stream physical layer to the task scheduling domain in real time. This enables task priorities to respond simultaneously to burst impacts from external data streams and the urgency of internal deadlines, avoiding scheduling imbalances caused by single-dimensional decision-making. On this basis, this invention dynamically allocates dedicated processing cores and shared processing cores according to task priorities, and selectively suspends high-slack tasks that meet safety conditions to release computing resources when core capacity is insufficient. At the same time, it introduces hysteresis boundaries based on migration overhead during task migration to prevent frequent round-trip migrations between cores, effectively reducing the computing power loss caused by context switching. Furthermore, this invention provides emergency computing power for urgent tasks by triggering shared core memory access bandwidth throttling when sufficient execution slots cannot be released after traversal. At the instruction scheduling level, task priority is directly converted into instruction-level execution order, shortening the response path from readiness to actual occupation of execution slots for highly urgent tasks. After task execution, the actual computing power occupation time and waiting time are written back to the historical record, forming a closed-loop scheduling architecture of "perception-decision-resource reconstruction-execution-feedback". This enables edge nodes to adaptively track changes in data flow rhythm and system load fluctuations. Under the constraints of integrated circuit computing power resources, it achieves synergistic optimization of task scheduling accuracy, system throughput and long-term stability. It can be widely deployed in real-time sensitive edge computing scenarios such as smart manufacturing production lines, industrial IoT gateways and autonomous driving domain controllers. Attached Figure Description

[0042] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort. In the drawings:

[0043] Figure 1 This is a flowchart of an integrated circuit application optimization method based on edge computing according to an embodiment of the present invention.

[0044] Figure 2 This is a schematic diagram illustrating an application scenario of the edge computing-based integrated circuit application optimization method according to an embodiment of the present invention. Detailed Implementation

[0045] Hereinafter, exemplary embodiments according to the present invention will be described in detail with reference to the accompanying drawings. Obviously, the described embodiments are merely some embodiments of the present invention, and not all embodiments of the present invention. It should be understood that the present invention is not limited to the exemplary embodiments described herein.

[0046] Figure 1 This is a flowchart of an integrated circuit application optimization method based on edge computing according to an embodiment of the present invention. Figure 1 As shown, the edge computing-based integrated circuit application optimization method includes:

[0047] S1. The edge node data stream feature extraction module receives multiple data streams from multiple devices, multiple sensor channels, or multiple field control ports. After converting the timestamps, time intervals, task execution time limits, and scheduling time of each data stream to the same reference time unit, it establishes data stream records according to the source port identifier. Then, it reads the stream type configuration table to classify the data streams into periodic streams and event streams. For periodic streams, it determines the burst arrival mode and burst level based on the dynamic judgment boundary formed by the arrival interval dispersion within the sliding time window and the stable operation samples of the corresponding source port. For event streams, it determines the initial burst level based on the event type and event status and performs time decay processing. On this basis, it matches the criticality level of the corresponding task according to the source port identifier, generates data stream feature tags containing stream type, burst arrival mode, burst level, and task criticality level, and sends the data stream feature tags to the task priority calculation module.

[0048] Specifically, the edge node can be an edge controller, industrial computing unit, embedded computing module, or integrated circuit control node with multiple processing cores deployed on the side of the intelligent manufacturing production line. The multiple data streams can originate from temperature sensors, pressure sensors, vibration sensors, displacement sensors, machine vision equipment, servo drives, process inspection devices, safety light curtains, equipment status controllers, or other production line equipment. Each data stream is bound to a source port identifier, which can consist of one or more of the following: physical interface number, network port number, fieldbus address, logical channel number, data frame type, and data stream number generated by the interface controller. For data streams carrying multiple tasks on the same physical port, they can be further distinguished based on message type, data frame type, sub-channel number, or task identifier, thereby ensuring that data in the same statistical sequence has the same source and processing attributes.

[0049] The timestamp is preferably written by a hardware timer by the edge node when the data packet or data frame enters the receive buffer, or generated by the receive interface circuit according to a unified timing benchmark. If the source device itself carries a timestamp, the edge node converts it based on the device clock offset, clock frequency deviation, and synchronization calibration records, so that the timestamps of different source devices are all converted to the unified timing benchmark of the edge node. To avoid distortion of calculation results due to inconsistencies in microseconds, milliseconds, processor clock cycles, or system tick units when the program is ported between different hardware platforms, this embodiment sets a system reference time before all statistical and scheduling calculations. The raw time read from the hardware timer Convert to normalized time:

[0050]

[0051] in, Determined by both the hardware timer resolution and the system time base. This is a dimensionless time value. Subsequent arrival intervals, task waiting times, task execution time limits, and core occupancy times obtained by subtracting timestamps are all represented using this normalized time. For integrated circuits using fixed-point arithmetic, this can be... Stored as fixed-point numbers in a uniform format, such as using the same number of decimal places and saturated arithmetic logic; for processors using floating-point operations, single-precision or double-precision floating-point numbers are used. By standardizing the time representation before entering the algorithm, orders of magnitude deviations caused by inconsistent units are prevented between different time quantities in the same formula.

[0052] The data stream feature extraction module reads the stream type configuration table, which includes at least the source port identifier, stream type, corresponding task identifier, event type, whether the event needs to be continuously maintained, the initial value of the event burst level, the event decay duration, and the task criticality level. Periodic streams refer to data streams with a relatively stable sampling period or stable data generation rhythm under normal operating conditions, such as servo control sampling streams, temperature periodic sampling streams, vibration continuous sampling streams, and visual frame streams. Event-driven streams refer to data streams driven by state changes, alarm triggers, equipment interlocks, or discrete events, such as safety light curtain trigger streams, fault interruption streams, alarm notification streams, and equipment state inversion streams.

[0053] For periodic streams, the data stream feature extraction module maintains timestamp buffers according to the source port identifier. Upon receiving a valid data packet, it reads the normalized timestamp of the current packet and the normalized timestamp of the previous valid data packet from the same source port to obtain the adjacent arrival interval. Let the source port... In the current sliding time window The effective arrival interval formed within is The module then calculates the dispersion of arrival intervals within the current window. The sliding time window can be established based on the number of valid arrival intervals or on a normalized time length. The window length is determined based on the source device's rated sampling period, task control period, allowable response time of control commands, and the shortest burst duration to be identified. To avoid excessive impact from individual communication jitter on the results, the sliding window can use a circular buffer to store valid arrival intervals within the most recent period.

[0054] When timestamps are duplicated, timestamps are reversed, or timestamps wrap around using a timer, the data stream feature extraction module prioritizes correction based on the packet sequence number, interface sequence number, and timer wraparound flag. Data records that cannot be corrected are marked as invalid and excluded from the current window's dispersion calculation. If the number of valid arrival intervals in the current window is insufficient to generate the required sample size for variance calculation, the burst state and burst degree of the previous valid window are retained, and new data records continue to be received, avoiding frequent changes to the data stream label when samples are insufficient.

[0055] In one implementation, to ensure that the burst judgment of periodic data streams directly reflects the degree of deviation of the current arrival rhythm from the stable operating state, and to avoid excessive elevation of the dynamic boundary caused by simply adding the upper quantile and dispersion of stable samples, the following formula can be used to determine the dispersion, variance multiple relationship, dynamic judgment boundary, and burst degree of the current window:

[0056]

[0057]

[0058]

[0059]

[0060] in, Indicates the source port The variance of the arrival interval in the current window; since the arrival interval has been represented using normalized time, therefore It is a dimensionless quantity. This represents the average of the valid arrival intervals within the current window. This indicates the number of valid arrival intervals. Indicates the source port The baseline variance formed under stable operating conditions, and its relationship with They have the same dimensionless representation. This is the smallest significant positive number after normalization. Its value is determined based on the timer resolution, the number of fixed-point decimal places, and the smallest distinguishable time interval. Its function is to prevent division by zero or numerical divergence when the reference variance is close to zero. Because , and All are dimensionless quantities. This represents a dimensionless variance multiple relationship.

[0061] The benchmark variance The variance sample is formed from the variance samples obtained from the source port within a stable operating window. A stable operating window refers to a window where the data stream is not in a burst state, the interface is not in a retransmission recovery state, the packet loss rate is within a normal range, the corresponding task has no persistent queue backlog, and the edge node has not experienced a core failure. Burst windows, communication recovery windows, packet loss retransmission windows, and sensor failure windows are not included in the baseline statistics. For the stable variance sample, the median, fixed-proportion truncated mean, or other robust central tendency estimation methods can be used. The aforementioned Represents a stable sample set The robust central tendency is measured, not the unprocessed arithmetic mean. To ensure statistical consistency, and All use the same robust estimation method; for example, when When using the median as the basis, It is also formed using the median; when When the truncated mean is formed using the same proportion, The same truncation ratio was also used in the calculation.

[0062] Indicates the source port The set of variance multiples of a sample formed within a stable window; This represents the upper quantile of the stable sample set; This represents the median absolute deviation of the sample set; and All of these are dimensionless parameters. Determined based on the proportion of normal fluctuations allowed during periods of stable historical production. The dynamic judgment boundary is determined based on the degree of distinction between stable jitter and actual sudden events. The larger of the upper quantile and the robust central tendency plus the deviation term is chosen, ensuring that the boundary simultaneously covers both the tail fluctuations of stable samples and the overall drift of the stable distribution. Compared to directly adding the two statistics, this upper envelope processing avoids additional superposition of dispersion under extremely stable distributions.

[0063] This indicates the burstiness level of the current data stream, with a value ranging from 0 to 1. For periodic streams, when... Not exceeding hour, A value of 0 indicates that the current arrival rhythm has not significantly deviated from the stable operating state; when Exceed hour, The deviation increases continuously. It is a dimensionless numerically stable term, determined based on the smallest significant number in the current calculation format. The function limits the calculation results to the range of 0 to 1 to prevent extreme outlier windows from causing unbounded amplification of subsequent priority exponents.

[0064] For event-driven streams, the data stream feature extraction module skips the arrival interval variance determination for periodic streams. The initial burst level of a one-off event stream is also considered. The event is formed based on the event type, device alarm level, the impact of the event on the current control chain, and the allowed response time of the event, and is normalized to 0 to 1 by the event mapping table. Indicates the time of the most recently confirmed valid event. Indicates the current scheduling time. This indicates the normalized decay duration corresponding to this event type. Its source can be the equipment alarm hold time, control system reset cycle, maximum allowed event processing time, or historical event processing records. The suddenness of a one-off event decays linearly over time. Then decay to 0; if a new event of the same type with a different event sequence number or an already confirmed state reversal is received, refresh. It then begins to decay again.

[0065] To prevent event-driven data streams from continuously updating burst levels due to repeated reporting of background noise, edge nodes can further deduplicate events based on event sequence numbers, device state inversion flags, event acknowledgment flags, and device reset flags. Duplicate messages with the same event sequence number but without a state inversion are not refreshed. A new valid event is only considered to occur when the event state changes from never triggered to triggered, the event sequence number changes, the device is retried after a reset, or the event content undergoes a substantial change that meets the business definition. For security state flows that must maintain their priority continuously, they must be maintained until a reset event is received. For ordinary alarm streams that are not required to be continuously maintained, they will gradually recover to a non-sudden state according to the decay process.

[0066] When a source port fails to establish a new stable window for an extended period, the edge node does not directly write the current operating data into the stable baseline. Instead, it initiates baseline recalibration based on the validity period of the baseline sample, device runtime, and the continuous drift of recent data distribution. Recalibration can employ a robust update method with a time forgetting factor, excluding burst windows, communication recovery windows, and event confirmation windows during the update process. If the baseline sample has not been updated for a long time but the current data still cannot meet the stable operating conditions, the most recently valid baseline is retained, and the baseline freshness status in the tag is set to expired. This reduces S2's reliance on the burst judgment result when calculating task priorities. This avoids baseline freezing and also prevents the absorption of abnormal data into the stable baseline during periods of continuous anomalies.

[0067] After burst identification is completed, the data stream feature extraction module queries the task criticality mapping table based on the source port identifier. The mapping table includes at least the source port identifier, stream type, task identifier, task output object, task criticality level, task execution time limit source, allowed processing core type, and event reset condition. If the data stream processing result is directly used for servo control, process parameter closed-loop correction, actuator action, equipment protection, or safety interlocking, the corresponding task is marked as high criticality. If the data stream is mainly used for equipment status display, trend statistics, log recording, or offline analysis, the corresponding task is marked as ordinary criticality. The final data stream feature tag includes at least the source port identifier, task identifier, stream type, burst arrival mode, burst severity, event time status, task criticality level, data quality status, and configuration version number. This tag is then bound to the corresponding task descriptor and sent to S2.

[0068] For example, source port 4101 connects to a periodic process control sensor. The normalized arrival interval variance within the current window is 0.025, corresponding to a stable operating baseline variance of 0.010, resulting in a variance multiple of 2.5. The upper quantile of the stable sample set at this port is 1.52, the stable central tendency obtained using the same robust statistical caliber is 1.08, the median absolute deviation is 0.12, and the deviation adjustment coefficient is 2. Therefore, the second boundary term is 1.32, and the dynamic decision boundary takes the larger of the two, 1.52. Since 2.5 exceeds 1.52, the current burst level is calculated based on the deviation level and limited to between 0 and 1, yielding the burst arrival pattern and the corresponding continuous burst level. Source port 4102 connects to the security light curtain and is an event-driven one-time stream. The event mapping table gives an initial burst level of 0.90 based on the security event level. After a normalized time interval of 0.4 and a decay duration of 1.0, and without any new valid state transitions, the current burst level is 0.54. If subsequent packets only repeat the original event sequence number, the event time is not refreshed. The port numbers, variances, boundaries, and event values ​​mentioned above are only used to illustrate the processing procedure and do not limit the port type, statistical window, and parameter values ​​of this invention.

[0069] S2: The task priority calculation module reads the data stream feature labels generated in S1 and the execution time limit, current queue cumulative waiting time, and historical computing power occupation time in the task descriptor. It calculates the remaining tolerable latency of the task at the current scheduling time using a unified reference time unit, and constructs a dimensionless time slack using the remaining tolerable latency and the historical computing power occupation time. When the data stream feature labels simultaneously represent a burst arrival mode and a high criticality level, the time slack is continuously decayed according to the burst level and task criticality. At the same time, the dynamic lower limit of the decay coefficient is determined according to the minimum service requirements of the shared task to obtain the task priority index. The task priority index is used as the input for core mapping, task state maintenance, and candidate task selection in S3.

[0070] Specifically, the task priority calculation module reads the task identifier, data stream arrival time, task execution time limit, queue entry time, current task status, historical execution records, and current core affiliation from the task descriptor. The execution time limit represents the maximum allowed time between the arrival of the data stream and the generation of the task output result, and can be determined based on the equipment control cycle, actuator response time, safety interlock time limit, process parameter update cycle, or task watchdog time limit. If the task is described using an absolute deadline, the normalized execution time limit is obtained by subtracting the data stream arrival time from the deadline; if the task is described using a relative time budget, the normalized time budget in the task configuration is directly read.

[0071] The current queue cumulative waiting time represents the total time a task has been in the executable waiting queue but has not yet actually occupied a processing core for execution. Waiting time incurred due to insufficient dedicated core capacity, being delayed by other tasks, being re-queued after being safely suspended, or undergoing core migration can all be accumulated continuously. The time a task actually occupies a processing core to execute instructions is not included in the queue waiting time but is recorded as the computing power usage time. The time a task waits on shared resources, waits for external device responses, or waits for DMA completion can be recorded separately to distinguish between the task's own computational needs and external resource blockages.

[0072] Historical computing power usage time represents the estimated time required for a task to complete one processing cycle on the current edge node. Edge nodes use a processing core cycle counter to record the start, pause, resume, and completion times of tasks, removing any waiting periods that do not occupy processing cores, thus forming a valid computing power usage record. For tasks where the input data size affects execution time, historical records can be grouped according to the number of data packets, data bytes, sensor channels, image size, or instruction blocks, prioritizing records matching the current input size. For tasks running for the first time without valid historical records, the worst-case execution cycle generated during the task compilation phase, offline test data, or the initial time calculated based on the number of instructions and the core's rated frequency can be used, gradually replacing these with runtime measurements after actual execution.

[0073] To prevent exponential decay from completely excluding ordinary tasks during periods of high burst intensity, the task priority calculation module generates a dynamic minimum guarantee coefficient based on the minimum service requirements of the current shared task set. Let the set of tasks currently in a ready state and requiring shared core processing services be... Each task The minimum service time required within a scheduling cycle is Scheduling cycle The proportion of shared task service demand can be obtained based on the relationship between the sum of the minimum service times of each task and the scheduling cycle, and the minimum guaranteed range of the attenuation coefficient can be determined based on this proportion. The minimum service time of a task can be determined by the log refresh cycle, monitoring sampling cycle, device status update cycle, task watchdog requirements, or historical actual service records. The more shared tasks, the longer the minimum service time, or the greater the service gap of shared tasks, the higher the lower limit of the attenuation coefficient, thereby limiting the continuous crowding out of shared tasks by highly critical tasks; when there is no shared task service demand or shared tasks have been fully served, the lower limit of the attenuation coefficient falls back to the system base value, enabling highly critical tasks to obtain strong burst response capabilities.

[0074] In one implementation, the remaining tolerance delay, time slack, dynamic minimum guarantee coefficient, burst decay coefficient, and task priority index can be determined using the following formula:

[0075]

[0076]

[0077]

[0078]

[0079]

[0080]

[0081] in, Indicates task Normalized execution time limit, Indicates task The normalized cumulative waiting time of the queue, both of which are dimensionless time values; This represents the remaining tolerable delay that the task can still complete at the current scheduling moment. Reaching or exceeding hour, A value of 0 indicates that the task has entered a deadline risk state. The historical computing power usage time is also represented using normalized time. This is the minimum effective time after normalization, used to avoid division-by-zero errors when the historical computing power usage time is close to zero.

[0082] The slack time reflects the margin of the task's remaining response time relative to the expected core execution time. When A larger value indicates that the task has a larger remaining time and space; when A value close to or less than 1 indicates that the remaining tolerance latency of the task is close to or less than the expected execution time, requiring a more advanced scheduling position. Here, 1 only represents a neutral feasibility relationship where the remaining time is comparable to the expected execution time, and is not used as a single point of failure for task state switching in S2. Whether the task enters a dedicated core, releases its execution slot, and triggers core migration is determined by S3 based on the task state logic with a hysteresis region.

[0083] It represents the minimum service demand ratio of the current shared task set within a scheduling cycle, and is a dimensionless quantity. and Both are normalized time values, therefore the ratio between the two is dimensionless. This is the lower limit of the system's basic attenuation. The attenuation coefficient is the maximum allowable lower limit, satisfying... . The dimensionless reference ratio for the minimum service requirements of shared tasks can be derived from shared task service contracts, historical service gap statistics, and the design results of task watchdog cycles or system scheduling cycles. Dynamically adjust based on current shared task service demand: When the shared task set is empty or service demand is low. near When the minimum service requirements for shared tasks increase, The increase in priority limits the compression of high-critical tasks, thus reserving minimum service time for shared tasks.

[0084] This indicates the burst arrival mode of S1 output; it is 1 when the burst arrival mode is active, and 0 otherwise. This indicates that the task is classified as high-criticality. This indicates the burst level of the S1 output, with a value ranging from 0 to 1; This represents the criticality coefficient of the task, and is a dimensionless quantity. Normalization can be performed based on whether the task directly controls the actuator, the degree of impact of the task on equipment protection, the allowable response time of the task, and the position of the task output in the control chain. It is a dimensionless attenuation intensity coefficient, which can be jointly calibrated based on historical task sequence playback, control error allowable range, context switching overhead, and shared task service gap.

[0085] Input of the exponential function As a dimensionless quantity, output It is also a dimensionless quantity, ranging from 0 to 1. As the urgency or criticality of the task increases, this exponential term decreases, lowering the task priority index and indicating a more urgent task. This can be determined by taking the exponential term and... The larger of the two values ​​is used to ensure that the attenuation coefficient does not fall below the minimum guarantee range allowed by the current shared task service requirements. This lower limit is not a simple fixed constant, but is dynamically calculated based on the minimum service requirements within the current shared task set and scheduling cycle, thereby preventing ordinary monitoring, logging, or device status tasks from being permanently suspended when a large number of highly critical tasks occur simultaneously.

[0086] This is a task priority index; the smaller the value, the more urgent the task. S2 Output The remaining tolerance latency, pre-computational power occupancy time, attenuation coefficient, task criticality level, and current shared task service demand status are considered. For tasks with the same priority index or within the same calculation precision range, auxiliary sorting can be performed based on absolute deadline, task criticality level, and data stream arrival time. The task priority index is recalculated upon new data stream arrival, changes in waiting time, task completion, task suspension, task resumption, and changes in the processing core state. S2 does not depend on... Instead of directly performing a core switch, the continuous priority is transferred to S3, which then determines whether to change the task ownership based on the current task status and migration overhead.

[0087] For example, if the execution time limit for task T1 is 800 microseconds, the current cumulative waiting time in the queue is 300 microseconds, and the historical computing power usage time is 400 microseconds, then its remaining tolerance latency is 500 microseconds, and the original latency slack is 1.25. Assuming the burstiness of the data stream corresponding to S1 outputting T1 is 0.56, and T1 is a highly critical task... The exponential decay term is approximately 0.715. If the minimum service demand ratio of the current shared task within a scheduling cycle is 0.08, the reference ratio is 0.2, the basic lower limit is 0.1, and the maximum lower limit is 0.8, then the dynamic minimum guarantee coefficient is 0.4, the final decay coefficient remains 0.715, and the task priority index is approximately 0.894. If the service demand of the shared task further increases, causing the dynamic minimum guarantee coefficient to reach 0.8, then the task decay coefficient will not be lower than 0.8, thereby preventing highly critical tasks from continuing to infinitely compress ordinary tasks when there is already a service gap in the shared task. The above values ​​are only used to illustrate the input, processing, and output relationships and do not limit the task time limit, decay parameters, or service guarantee ratio of this invention.

[0088] S3, the computing resource management module determines whether a task should enter a dedicated processing core, maintain its current core ownership, or release an execution slot based on the continuous task priority index output by S2, the task's current core ownership, and the integrated circuit processing core status. When a low-slack task needs dedicated processing power but the current dedicated core capacity is insufficient, the resource management module selects a task that can be safely suspended from the currently ready high-slack tasks that meet the candidate conditions, checks its cross-core shared resource occupancy status and safe suspension position, saves the context of the task that meets the conditions, and releases the corresponding execution slot. When it is still impossible to release enough execution slots after traversing the candidate tasks, it triggers emergency execution slot reservation or shared core memory access bandwidth limiting based on the remaining tolerable latency of the low-slack task and the current resource status. Finally, it generates a computing power allocation mapping table containing core mapping, task status, context status, bus service status, and recovery conditions.

[0089] Specifically, the dedicated processing core can be a physical processing core reserved for real-time control tasks in an integrated circuit, or it can be a hardware thread, an independent execution slot, or a dedicated acceleration unit logically partitioned by the resource management module. The shared processing core is used to perform monitoring, statistics, logging, trend analysis, device status updates, or other tasks that can be delayed. The dedicated core and the shared core can be fixed in hardware or dynamically partitioned through core role registers, task affinity registers, or scheduling permission registers.

[0090] The resource management module first reads the core status register, hardware thread status, fault isolation status, current instruction segment status, and core security status to obtain the current effective capacity of the dedicated processing core. The current effective capacity is the actual number of execution slots that can currently receive low-slack tasks, not the total number of physical cores. Execution slots in reset, fault isolation, islanded, performing non-migratable operations, or not yet initialized are not included in the current effective capacity. For processing cores with multiple independent hardware threads, each hardware thread capable of independently storing its context and receiving task descriptors can serve as an execution slot.

[0091] To avoid repeated core migrations when task priorities change near neutral relationships, the resource management module maintains a lag state for tasks based on migration overhead. The times for context saving, context restoration, and queue switching are actually measured by the processing core cycle counter, and normalized migration overhead is formed based on the historical computing power usage time of the task. In one implementation, the dynamic decision boundary for entering and exiting a dedicated core can be determined using the following relationship:

[0092]

[0093]

[0094]

[0095] in, Indicates task Context save time, Indicates context recovery time. This represents the time required for queue descriptor update, queue head pointer switching, and instruction fetch restart. All three are measured by the core cycle counter and converted into a unified normalized time. The historical computing power consumption time of the task. As a normalized numerically stable term, therefore This represents the proportion of dimensionless migration overhead. and Instead of a fixed priority value manually assigned to the task result, it is an effective boundary for migration overhead determined based on the minimum measurable migration overhead of the processing core, the core scheduling cycle, and the fixed-point computation range, and satisfies... .

[0096] For tasks currently located in the shared processing core, when Less than or equal to At that time, the resource management module marks it as a task candidate that needs to enter the dedicated processing core; when In and During this period, the current core affiliation and task state of the task remain unchanged; for tasks already located in a dedicated processing core, only when... Greater than or equal to A task is only allowed to be released back to the shared processing core when it has completed its real-time processing requirements, has no highly critical follow-up tasks awaiting its results, and there are available execution slots on the shared core. Because of the hysteresis region formed by the actual migration overhead between the entry and exit boundaries, fluctuations in task priority within this region will not trigger round-trip migration between the dedicated core and the shared core.

[0097] When the number of low-slack tasks does not exceed the current effective capacity of the dedicated processing core, the resource management module maps low-slack tasks to compatible dedicated processing cores in ascending order of task priority index. If different dedicated cores have different instruction sets, cache capacities, vector computation capabilities, or dedicated acceleration capabilities, incompatible cores are first excluded based on task resource requirements. Then, among the compatible cores, execution slots with shorter current queues, where input data is already resident, or where the context is already resident are selected. Tasks already on dedicated cores and whose priority is within the lag zone maintain their original mapping and are not reordered or migrated due to minor changes in priority.

[0098] When the number of low-slack tasks exceeds the current effective capacity of a dedicated processing core, the resource management module first identifies low-slack tasks that have not yet acquired a dedicated execution slot, and then establishes a set of high-slack candidate tasks. This candidate task set only includes tasks that are currently in a ready state, located in a shared processing core, whose task priority index has reached the dynamic decision boundary for exiting a dedicated core, whose input data is ready, and which are not waiting for preceding tasks. Tasks that are in a blocked state, waiting for external devices, have not yet reached a safe suspension position, are still in the lag zone, or already hold cross-core shared resources are not directly included in the suspendable candidate set. The candidate set can be maintained by a ready task index, a priority heap, or a per-core candidate list, and arranged in descending order of task priority index, so that the resource management module only traverses candidate tasks that meet the current requirements, without having to scan all tasks in the system.

[0099] The resource management module reads the cross-core resource status table for candidate tasks. These cross-core resources include at least cross-core mutexes, semaphores, shared buffer write transactions, DMA transactions, shared accelerator calls, on-chip bus exclusive transactions, cross-core atomic operations, and incomplete cache consistency write-back transactions. When a task acquires a resource, it registers the task identifier, resource identifier, resource acquisition time, and expected release status in the resource status table; when the task releases the resource or the asynchronous transaction completes, the corresponding registration is cleared. If the candidate task's cross-core resource occupancy bitmap is empty, there are no incomplete DMA transactions, no uncommitted atomic operations, and no shared buffer transactions that depend on its immediate completion for writes, then the safe suspension position detection continues; if any resource is still occupied, the task is skipped and the next candidate task is checked.

[0100] The safe suspension point can be a complete machine instruction commit point, a task checkpoint inserted by the compiler, the end point of an instruction block, the end point of a loop iteration, or a point where the architectural state can be completely saved. When a task is in an indivisible instruction segment, in the process of continuous writing to device registers, or when a partial state has not yet been committed, the resource management module only sets a suspension request flag and does not directly stop the processing core. After the processing core reaches the nearest safe suspension point, it stops acquiring subsequent instructions for the task and commits the completed storage writes to a state observable by other processing cores.

[0101] After a candidate task meets the cross-core resource safety conditions and the safe suspension position conditions, the resource management module saves the task's program counter, stack pointer, general-purpose registers, status register, vector register, task local memory address, next instruction to be executed location, cache consistency status, and context version number. If dirty data exists in the task's local cache, it is written back while maintaining cache consistency, or the corresponding cache directory status is registered in the context descriptor. After the context is saved, the task status is set to "suspended," the original execution slot is marked as available for borrowing, and the execution slot is temporarily added to the dedicated core pool. Temporarily adding it to the dedicated core pool only changes the task's receiving permissions and queue ownership for the current scheduling cycle and does not require changes to the physical core circuit structure.

[0102] If enough execution slots have been released after traversing the candidate tasks in priority order, the resource management module will sequentially map the unmapped low-slack tasks to the newly released execution slots. If some candidate tasks are skipped because they hold shared resources, a resource release event is registered, and candidate detection is performed again after the corresponding resources are released. If enough execution slots cannot be released after traversing all candidate tasks, the resource management module first checks whether there are emergency execution slots reserved by the system scheduling cycle or minimum guaranteed time slices of the shared core. The emergency execution slots can be time slices reserved from the shared core in each scheduling cycle, or idle hardware threads in dedicated processing cores.

[0103] When no directly available execution slots exist, and low-slack tasks in the urgent waiting queue cannot be completed on time under normal memory access service based on their remaining tolerable latency, historical computing power occupancy time, and current bus waiting state, the resource management module triggers shared core memory access bandwidth throttling. The urgent determination is based on the feasible relationship between the task's remaining tolerable latency and the minimum execution time required to complete the task, the current memory access waiting time, and the bus recovery response time, rather than on fixed values ​​indicating departure from the running state. After triggering memory access bandwidth throttling, the resource management module reduces the memory access service weight of the shared processing core through the on-chip bus quality service register, memory controller arbitration register, outstanding transaction limit register, or bandwidth token controller, reducing the number of incomplete read / write transactions, limiting memory access tokens within a unit scheduling cycle, and increasing the service weight of memory access transactions corresponding to low-slack task control data.

[0104] The memory access bandwidth limiting does not revoke mutexes, semaphores, or DMA transactions already held by shared core tasks, does not forcibly interrupt cross-core atomic operations, and does not modify the ownership of shared resources. It only releases bus cycles by compressing the effective memory access rate of shared tasks, allowing low-slack tasks that have already acquired execution slots to prioritize data reading and result writing back. If the hardware supports time-slice time-sharing on shared cores, the released bus cycles and reserved execution time slices are used together to execute low-slack tasks. If the hardware does not support generating available execution slots through memory access limiting, the resource management module does not mistakenly record the bandwidth limiting as an idle processing core, but instead keeps low-slack tasks in the urgent waiting queue and writes the urgent waiting status and bandwidth service status into the mapping table.

[0105] The computing power allocation mapping table records at least the task identifier, task priority index, current task status, original processing core identifier, target processing core identifier, target execution slot identifier, context storage address, context version number, cross-core resource status, migration lag status, bandwidth service status, mapping activation period, and task recovery conditions. The mapping table can be updated using a double-buffered structure. The resource management module first writes the complete mapping content to the inactive region and completes consistency verification, then atomically switches the active mapping region. For tasks in the lag region, the mapping table retains the original core affiliation and does not generate new migration instructions. For scheduling periods that have triggered emergency bandwidth throttling, the mapping table records the throttling start status and release conditions so that S4 can synchronously update the bus service configuration during queue switching.

[0106] For example, the current dedicated processing core has two valid execution slots. S2 outputs low-slack tasks A, B, C, and D, with priority indices of 0.42, 0.58, 0.76, and 0.93, respectively. The shared processing core runs high-slack tasks H1, H2, and H3, with priority indices of 5.6, 6.3, and 8.1, respectively. The resource management module first maps A and B to the two original dedicated execution slots, then checks H3, H2, and H1 according to the priority release order of high-slack tasks. H3 does not hold a cross-core lock, has no outstanding DMA transactions, and is in the instruction block commit position, therefore it is suspended and one execution slot is released; H2 is holding a shared DMA buffer, therefore it is skipped; H1 does not hold cross-core resources and is in a safe suspension position, therefore it is suspended and another execution slot is released. C and D are mapped to two temporary dedicated execution slots respectively. If H3, H2, and H1 all hold cross-core resources, the resource management module does not forcibly release the resource occupancy, but instead checks the emergency execution time slice. When the urgent waiting task no longer has the time feasibility under normal memory access service, the arbitration weight of shared core memory access transactions is reduced and the bus access weight of low-slack tasks is increased, while retaining the resource ownership of each task. The task names, priorities, and core counts mentioned above are only used to illustrate the processing procedure and do not limit the number of tasks, core structure, or bus control method of this invention.

[0107] S4, the instruction scheduling module reads the computing power allocation mapping table generated by S3, generates an instruction scheduling descriptor based on the task target processing core, target execution slot, task priority index, and task status, inserts the next executable instruction segment of low-slack tasks that have already satisfied input dependencies into the front of the corresponding instruction queue, and decides whether to perform cross-core context recovery based on the task status lag result; at the same time, it writes the bus bandwidth service status generated by S3 into the scheduling configuration of the on-chip bus or memory controller, so that low-slack tasks can obtain instruction fetch, memory access, and result write-back services first, and finally form a dynamic scheduling instruction sequence that maintains the internal instruction order of tasks, cross-task data dependencies, integrity of shared resources, and consistency of context versions.

[0108] Specifically, the instruction scheduling module reads the task identifier, target processing core identifier, target execution slot identifier, task priority index, task context address, task current state, migration lag state, bandwidth service status, and mapping version number from the computing power allocation mapping table, and constructs an instruction scheduling descriptor for each mapped task. The instruction scheduling descriptor includes at least the task identifier, the program counter of the next instruction to be executed, the instruction segment start address, the instruction segment end address, the input data address, the target processing core identifier, the context version number, the dependency status, the memory access service level, and the descriptor validity flag. The next executable instruction segment can be pre-divided by the compiler or by the runtime based on the task's safe suspension position. Each instruction segment starts at a position where the task state can be fully restored and ends at the next position where it can be safely suspended.

[0109] Before inserting the instruction descriptor of a low-slack task into the front of the instruction queue, the instruction scheduling module checks whether the task input data has been written, whether the preceding task has been completed, whether the corresponding DMA transaction has ended, whether the shared buffer is in a consistent state, and whether the necessary memory barriers are in effect. When the above conditions are met, the task status is set to executable, and its instruction descriptor is allowed to be written to the queue of the target processing core. When the task is still waiting for the result of the preceding task, the response from an external device, or the release of shared resources, the invalid descriptor of the task is not placed at the head of the queue. Instead, the dependent objects are registered, and the instruction descriptor is re-established after the dependency completion event arrives.

[0110] When multiple low-slack tasks correspond to the same target processing core, the instruction scheduling module arranges the task descriptors that have not yet started execution in ascending order of task priority index. If the task priority indices are the same, a secondary sorting is performed based on the absolute deadline, task criticality level, and data flow arrival time. For tasks already in a dedicated core whose priority changes between the entry and exit boundaries, the instruction scheduling module maintains their original core affiliation and queue state, and does not trigger context saving, context restoration, or cross-core migration due to this priority change; only for tasks whose priority has reached the entry boundary and whose mapping has been completed by the resource management module will the new target core queue insertion be performed.

[0111] For tasks suspended by a shared processing core and migrated to a dedicated processing core, the instruction scheduling module reads the program counter, stack pointer, general-purpose registers, status register, vector register, task-local storage information, and the location of the next instruction to be executed based on the saved context address, and constructs a recovery descriptor using the saved program counter. The resumed task continues execution from the suspended position, without re-executing completed instruction segments or rewriting already submitted processing results. Before context recovery, the instruction scheduling module verifies the task identifier, context version number, and current mapping version number; if the context version number is lower than the active mapping version number, it indicates that the context has expired and must not be written to the target instruction queue.

[0112] For shared core memory access bandwidth throttling triggered by S3, the instruction scheduling module synchronously updates the bus service configuration before switching the queue head pointer. Instruction descriptors for low-slack tasks carry a higher memory access service level or a larger bus arbitration weight, while descriptors for ordinary shared tasks carry a limited number of outstanding transactions or a lower memory access token rate. The bandwidth configuration only affects the arbitration order of memory access requests, request concurrency, and service quota per unit scheduling cycle; it does not revoke locks, semaphores, or DMA transactions already acquired by the task. For shared tasks performing cross-core atomic operations, the instruction scheduling module waits for the atomic operation to complete before applying the new queue state; for tasks that already hold cross-core resources but do not involve the current low-slack task's data path, memory access service throttling can be applied without changing resource ownership.

[0113] The instruction queue can employ a per-core circular queue, an on-chip task descriptor queue, a hardware multi-level priority queue, or a combination of an active queue and a shadow queue. When using a circular queue, the instruction scheduling module first writes the rearranged task descriptors to the shadow queue and performs verification, then atomically switches the queue head pointer and queue version number. When using a hardware priority queue, the fixed-point result of the task priority index is written to the descriptor sorting field, and the hardware comparison unit selects the descriptor with the lower task priority index and whose dependency states are already satisfied. Regardless of the queue structure used, the descriptor content should be written before the valid tag, and necessary memory barriers should be executed before updating the queue head pointer. The target processing core only begins fetching instructions after reading the valid tag and the current mapping version number.

[0114] For processing cores currently executing other tasks, the instruction scheduling module does not directly modify the program counter in the middle of machine instructions or indivisible instruction segments. If S3 has confirmed that the current task can be safely suspended, the processing core stops fetching instructions after reaching the safe suspension point, and the instruction scheduling module then writes the low-slack task descriptor to the front of the queue. If the current task still holds cross-core shared resources or has not yet reached the safe suspension point, its execution state is maintained, and the low-slack task enters the urgent waiting queue or uses the reserved emergency execution time slice. Thus, dynamic changes in task priority do not disrupt the continuity of instructions within the task, nor do they cause shared resources to be in an uncommitted state.

[0115] After forming a dynamic scheduling instruction sequence, the instruction scheduling module sends a queue update signal, a task scheduling interrupt signal, or a hardware queue version switch signal to the target processing core. The target processing core reads the new queue head descriptor, loads the corresponding task context, and fetches instructions starting from the program counter recorded in the descriptor. For shared processing cores temporarily converted to dedicated execution slots, the resource management module prohibits new ordinary high-relaxation tasks from writing to that execution slot during the execution of low-relaxation tasks; the temporary dedicated state is only released when the low-relaxation task completes, the task priority returns to above the exit boundary, and the shared task meets the recovery conditions. Upon release, the shared core memory access service configuration is first restored, then the recovery descriptor of the suspended task is written to the shared core queue, and finally the execution slot status is updated to avoid the recovery task and the real-time task simultaneously contending for the same execution slot.

[0116] During task execution, the instruction scheduling module uses the processing core cycle counter to record the actual start time, pause time, resume time, memory access wait time, and completion time of the task, respectively forming the actual computing power usage time, queue wait time, context migration overhead, shared resource wait time, and bandwidth throttling impact time. The actual computing power usage time is written into the task historical execution record for S2 updates. Context save and restore times are written to the migration overhead record for S3 to update the lag interval; minimum service time and service gap for shared tasks are written to the shared service record for S2 to update. The stable operation window and burst window of periodic data streams are written to the reference sample management area of ​​S1, and the valid event sequence number, reset status and decay status of event streams are written to the event status table.

[0117] Once a low-slack task completes, the processing core sets a task completion flag and releases the corresponding execution slot. The instruction scheduling module clears the valid descriptor for that task from the queue and updates the queue version number. After reading the completion flag, the resource management module first checks if any task priorities have reached the boundary for entering the dedicated core's dynamic decision-making process. If no new urgent tasks exist, the suspended high-slack tasks are resumed according to the recovery conditions in the mapping table. If urgent tasks are still waiting, the released execution slots are used for new low-slack tasks. For scheduling cycles that have triggered memory access bandwidth throttling, when a low-slack task leaves the urgent waiting queue or the minimum service gap of a shared task is compensated, the memory access service level, concurrent transaction count, and bandwidth token rate of ordinary shared tasks are restored.

[0118] For example, S3 maps low-relaxation tasks A, B, C, and D to four execution slots, where A and B use their original dedicated execution slots, and C and D use temporary dedicated execution slots released by high-relaxation tasks H3 and H1. The starting addresses of the next executable instruction segments for tasks A, B, C, and D are 1000, 2000, 3000, and 4000, respectively, and the context storage addresses for H3 and H1 are CTX3 and CTX1, respectively. The instruction scheduling module first checks the input data, prerequisites, and DMA status of the four low-relaxation tasks to confirm that the execution conditions are met; then, it writes the descriptors of A, B, C, and D to the shadow queue, postpones the descriptors of ordinary monitoring tasks, and reads CTX3 and CTX1 to restore the execution contexts corresponding to C and D. If the current scheduling cycle is under memory access bandwidth throttling, higher service levels are configured for the control data memory descriptors of A, B, C, and D, while restricted memory access tokens are configured for ordinary monitoring tasks. After descriptor verification and memory barriers are completed, the queue version is atomically switched, and the four execution slots fetch instructions starting from addresses 1000, 2000, 3000, and 4000, respectively. After task A completes, its actual computing power usage time, waiting time, and migration overhead are written to the feedback record. If a new low-slack task has not yet reached the entry boundary, H3 or H1 is restored according to the exit boundary and the minimum service requirements of the shared task. If the service gap of the shared task is still not compensated, the corresponding bandwidth configuration is maintained until the service status is restored. The above addresses, task names, queue structures, and service levels are only used to illustrate the dynamic instruction scheduling process and do not limit the processor architecture, number of tasks, or bus implementation of this invention.

[0119] In summary, the edge computing-based integrated circuit application optimization method based on the embodiments of the present invention is explained. It identifies the burst arrival patterns of data streams by performing time-series feature analysis on multiple data streams and maps the arrival rhythm changes of the data stream physical layer to the task scheduling domain in real time. This allows task priorities to respond simultaneously to burst impacts from external data streams and the urgency of internal deadlines, avoiding scheduling imbalances caused by single-dimensional decision-making. Furthermore, the present invention dynamically allocates dedicated processing cores and shared processing cores according to task priorities, and selectively suspends high-slack tasks that meet safety conditions to release computing resources when core capacity is insufficient. At the same time, it introduces a hysteresis boundary based on migration overhead during task migration to prevent frequent round-trip migrations between cores, effectively reducing the computing power loss caused by context switching. Furthermore, this invention provides emergency computing power for urgent tasks by triggering shared core memory access bandwidth throttling when sufficient execution slots cannot be released after traversal. At the instruction scheduling level, task priority is directly converted into instruction-level execution order, shortening the response path from readiness to actual occupation of execution slots for highly urgent tasks. After task execution, the actual computing power occupation time and waiting time are written back to the historical record, forming a closed-loop scheduling architecture of "perception-decision-resource reconstruction-execution-feedback". This enables edge nodes to adaptively track changes in data flow rhythm and system load fluctuations. Under the constraints of integrated circuit computing power resources, it achieves synergistic optimization of task scheduling accuracy, system throughput and long-term stability. It can be widely deployed in real-time sensitive edge computing scenarios such as smart manufacturing production lines, industrial IoT gateways and autonomous driving domain controllers.

[0120] Here, those skilled in the art will understand that the specific operations of each step in the above-described edge computing-based integrated circuit application optimization system have been referenced above. Figure 1 and Figure 2 The description of edge computing-based integrated circuit application optimization methods is detailed here, and therefore, its repeated description will be omitted.

[0121] In summary, the edge computing-based integrated circuit application optimization system based on the embodiments of the present invention is explained. It identifies the burst arrival patterns of data streams by performing time-series feature analysis on multiple data streams and maps the arrival rhythm changes of the data stream physical layer to the task scheduling domain in real time. This allows task priorities to respond simultaneously to burst impacts from external data streams and the urgency of internal deadlines, avoiding scheduling imbalances caused by single-dimensional decision-making. Furthermore, the present invention dynamically allocates dedicated processing cores and shared processing cores according to task priorities, and selectively suspends high-slack tasks that meet safety conditions to release computing resources when core capacity is insufficient. At the same time, it introduces a hysteresis boundary based on migration overhead during task migration to prevent frequent round-trip migrations between cores, effectively reducing the computing power loss caused by context switching. Furthermore, this invention provides emergency computing power for urgent tasks by triggering shared core memory access bandwidth throttling when sufficient execution slots cannot be released after traversal. At the instruction scheduling level, task priority is directly converted into instruction-level execution order, shortening the response path from readiness to actual occupation of execution slots for highly urgent tasks. After task execution, the actual computing power occupation time and waiting time are written back to the historical record, forming a closed-loop scheduling architecture of "perception-decision-resource reconstruction-execution-feedback". This enables edge nodes to adaptively track changes in data flow rhythm and system load fluctuations. Under the constraints of integrated circuit computing power resources, it achieves synergistic optimization of task scheduling accuracy, system throughput and long-term stability. It can be widely deployed in real-time sensitive edge computing scenarios such as smart manufacturing production lines, industrial IoT gateways and autonomous driving domain controllers.

Claims

1. A method for optimizing integrated circuit applications based on edge computing, characterized in that, include: Obtain the temporal characteristics and source identifiers of multiple data streams to determine the burst state of the data streams and the criticality level of the corresponding tasks; The task priority is determined based on the task's time limit information and computing power usage information, and the task priority is adjusted according to the aforementioned emergency situation and criticality level. Based on the adjusted task priority, tasks are assigned to dedicated processing cores, and when the capacity of dedicated processing cores is insufficient, suspendable tasks on shared processing cores are suspended to free up computing resources. Adjust the instruction queue of the integrated circuit according to the computing power resource allocation results, and execute each task according to the adjusted task priority.

2. The integrated circuit application optimization method based on edge computing according to claim 1, characterized in that, Determining the burst state of the data stream includes: Data streams are categorized into periodic streams and event streams. For periodic flows, the ratio of the variance of the arrival interval within the current sliding time window to the variance of the stable operating baseline is calculated as the variance multiple relationship. A dynamic judgment boundary is constructed based on the stable sample set. When the variance multiple relationship exceeds the dynamic judgment boundary, it is judged as a sudden state. For event-driven streams, the initial burst level is determined based on the event type and gradually decreases over time; The dynamic determination boundary Determined by the following formula: in, For a stable window of samples, To ensure a stable and concentrated trend, This represents the median absolute deviation.

3. The integrated circuit application optimization method based on edge computing according to claim 2, characterized in that, The event-type stream gradually decays over time, including: The burstiness of a one-off event stream decays linearly to zero over time according to the following formula: in, The initial level of suddenness corresponding to the event type. The time of the most recent valid event. For the current moment, The decay duration corresponding to the event type.

4. The integrated circuit application optimization method based on edge computing according to claim 3, characterized in that, Adjusting the task priority includes: When the data stream is in a burst state and the corresponding task is of high criticality, the timeliness slack, which is composed of the ratio of remaining tolerable latency to historical computing power occupancy time, is exponentially decayed based on the degree of burstiness and the task criticality coefficient, and the lower limit of decay is dynamically determined according to the minimum service requirements of the current shared task set.

5. The integrated circuit application optimization method based on edge computing according to claim 4, characterized in that, The process of assigning tasks to dedicated processing cores includes: The entry boundary for entering the dedicated processing core and the exit boundary for exiting the dedicated processing core are determined based on the task priority index and migration overhead ratio. The migration overhead ratio is determined by the ratio of the sum of context save time, context restore time, and queue switching time to the historical computing power usage time. The entry boundary is 1 minus the migration cost ratio, the exit boundary is 1 plus the migration cost ratio, the entry boundary is lower than the exit boundary, and a hysteresis region is formed between the two. When the task priority index is within the lag zone, the current core ownership remains unchanged. The migration from the shared processing core to the dedicated processing core is triggered only when the task priority index drops to the entry boundary. The release from the dedicated processing core to the shared processing core is triggered only when the task priority index rises to the exit boundary.

6. The integrated circuit application optimization method based on edge computing according to claim 5, characterized in that, The migration cost ratio Determine as follows: in, Save the time for the context of task i. For context recovery time, For queue switching time, Historical computing power usage time For numerically stable terms, and These represent the lower and upper bounds of the migration cost ratio, respectively.

7. The integrated circuit application optimization method based on edge computing according to claim 6, characterized in that, The suspendable tasks on the suspended shared processing core include: Traverse the tasks that are running on the shared processing core and meet the suspension candidate conditions, wherein the candidate conditions are that the priority of the task is lower than the exit boundary and the task is in a ready state. Detect whether each candidate task holds cross-core shared resources and whether it is in a safe suspended position; Prioritize suspending tasks that do not hold cross-core shared resources and are in a safe suspension position; If a candidate task still holds cross-core shared resources or is not in a safe suspended position, skip the task and continue to check the next candidate task.

8. An integrated circuit application optimization system based on edge computing, characterized in that, include: The data stream feature extraction module is used to obtain the temporal characteristics and source identifiers of multiple data streams, and to determine the burst state of the data streams and the criticality level of the corresponding tasks. The task priority calculation module is used to determine the task priority based on the task's time limit information and computing power usage information, and to adjust the task priority according to the aforementioned emergency status and criticality level. The computing resource management module is used to allocate tasks to dedicated processing cores according to the adjusted task priorities, and to suspend suspendable tasks on shared processing cores to release computing resources when the capacity of dedicated processing cores is insufficient. The instruction scheduling module is used to adjust the instruction queue of the integrated circuit according to the computing power resource allocation results, and execute each task according to the adjusted task priority.

9. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the integrated circuit application optimization method based on edge computing as described in any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the steps of the edge computing-based integrated circuit application optimization method according to any one of claims 1 to 7.