A private network dialing test task congestion self-recovery method and device and related media

Abstract

The application discloses a private network dialing test task congestion self-recovery method and device and related media, which comprises comparing the calculated queue length with the congestion trigger variable to obtain a congestion determination result; using the congestion determination result to generate a target pointer to obtain a target task pointer object; dialing test is performed according to the dialing test task configuration pointed to by the target task pointer object, and then queue synchronization update is performed to obtain an updated task queue and an updated queue length; when the updated queue length is greater than or equal to the congestion trigger variable, a new target task pointer object is generated, and the cycle is continuously performed until the updated queue length is less than the congestion trigger variable, and a scheduling termination instruction is output. The application synchronizes the task queue by dialing test according to the pointer, and the queue length is updated in a cycle until the threshold value is lower than the threshold value, the scheduling termination instruction is output, and thus the dialing test task congestion can be self-adjusted and recovered, and the problem of dialing test business exception is solved.

Description

Technical Field

[0001] This invention relates to the field of data processing, and in particular to a method, apparatus, and related media for self-recovery from congestion in private network dialing tasks. Background Technology

[0002] In recent years, connected vehicle services have developed rapidly in private network environments. To ensure end-to-end stability and performance, operators typically build a testing system consisting of a testing task scheduling center and distributed testing terminals. This system continuously sends testing tasks to terminals across various regions and aggregates the results to form a nationwide business situational awareness. In the existing technical architecture, terminals need to sign up for contracts and switch between multiple private networks. Testing cannot be performed during the switching period. When the task volume surges or terminals go offline due to force majeure, tasks accumulate in the queue and become congested, leading to increased testing execution latency and delayed situational awareness.

[0003] However, existing solutions generally lack congestion assessment and self-recovery scheduling mechanisms for dial-up test task queues. They cannot dynamically limit the execution range of similar tasks and synchronize queue status in a timely manner under task overload scenarios, making it difficult to resolve congestion in a timely manner and inducing dial-up test service anomalies. Summary of the Invention

[0004] This invention provides a method, apparatus, and related medium for self-recovery from congestion in private network dial-up testing tasks, aiming to solve the technical problem in the prior art where congestion in dial-up testing tasks is difficult to resolve in a timely manner, leading to abnormal dial-up testing services.

[0005] In a first aspect, embodiments of the present invention provide a method for self-recovery from congestion in a private network dialing test task, comprising: Connect to the test task source and perform standardized queuing to obtain the initial task queue; The queue length is calculated based on the initial task queue, and the queue length is compared with a preset congestion trigger variable to obtain a congestion determination result. The congestion determination result is used to generate a target pointer, resulting in a target task pointer object. Perform a test based on the test task configuration pointed to by the target task pointer object to obtain a test execution record set; The queue of the test execution record set is updated synchronously, and the task pointed to by the target task pointer object is dequeued from the initial task queue to obtain the updated task queue. The updated queue length is calculated based on the updated task queue; When the updated queue length is greater than or equal to the congestion trigger variable, a target pointer is generated based on the updated task queue to obtain a new target task pointer object. This process is repeated until the updated queue length is less than the congestion trigger variable, at which point a scheduling termination indication is output.

[0006] Secondly, embodiments of the present invention provide a congestion self-recovery device for private network dialing tasks, comprising: The data access unit is used to access the test task source and perform standardized queuing processing to obtain the initial task queue. The data comparison unit is used to calculate the queue length based on the initial task queue, compare the queue length with a preset congestion trigger variable, and obtain a congestion determination result. A pointer generation unit is used to generate a target pointer using the congestion determination result, thereby obtaining a target task pointer object; The test processing unit is used to perform test according to the test task configuration pointed to by the target task pointer object, and obtain a test execution record set; The queue update unit is used to perform queue synchronization update on the test execution record set and dequeue the task pointed to by the target task pointer object from the initial task queue to obtain the updated task queue. The length update unit is used to calculate the updated queue length based on the updated task queue. The scheduling output unit is used to generate a new target task pointer object based on the updated task queue return when the updated queue length is greater than or equal to the congestion trigger variable, and continuously loop until the updated queue length is less than the congestion trigger variable, and then output a scheduling termination indication.

[0007] Thirdly, embodiments of the present invention provide a computer device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the congestion self-recovery method for private network dialing test tasks of the first aspect.

[0008] Fourthly, embodiments of the present invention provide a computer-readable storage medium, wherein a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, it implements the congestion self-recovery method for private network dialing test tasks of the first aspect.

[0009] This invention provides a method for self-recovery from congestion in dedicated network dial-up testing tasks. The method includes: accessing a dial-up testing task source to obtain an initial task queue; calculating the queue length based on the initial task queue; comparing the queue length with a congestion trigger variable to obtain a congestion determination result; generating a target pointer using the congestion determination result to obtain a target task pointer object; performing dial-up testing according to the dial-up testing task configuration pointed to by the target task pointer object to obtain a dial-up execution record set; synchronizing and updating the queue of the dial-up execution record set, and dequeuing the task pointed to by the target task pointer object from the initial task queue to obtain an updated task queue; calculating the updated queue length based on the updated task queue; when the updated queue length is greater than or equal to the congestion trigger variable, generating a new target task pointer object based on the updated task queue, and continuously looping until the updated queue length is less than the congestion trigger variable, at which point a scheduling termination indication is output. This invention synchronizes the dial-up testing task queue by pointer and cyclically updates the queue length until it falls below a threshold, terminating and outputting a scheduling termination indication. In this way, dial-up testing tasks can self-recover from congestion, resolving the problem of dial-up service anomalies.

[0010] This invention also provides a dedicated network dialing test task congestion self-recovery device, computer equipment, and storage medium, which have the same beneficial effects as described above. Attached Figure Description

[0011] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the following description of the embodiments will be briefly introduced. 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.

[0012] Figure 1 A flowchart illustrating a method for self-recovery from congestion in a private network dialing test task, provided in an embodiment of the present invention; Figure 2 This is a schematic block diagram of a congestion self-recovery device for private network dialing tasks, provided as an embodiment of the present invention. Detailed Implementation

[0013] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0014] It should be understood that, when used in this specification and the appended claims, the terms "comprising" and "including" indicate the presence of the described features, integrals, steps, operations, elements and / or components, but do not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components and / or collections thereof.

[0015] It should also be understood that the terminology used in this specification is for the purpose of describing particular embodiments only and is not intended to limit the invention. As used in this specification and the appended claims, the singular forms “a,” “an,” and “the” are intended to include the plural forms unless the context clearly indicates otherwise.

[0016] It should also be further understood that the term "and / or" as used in this specification and the appended claims refers to any combination of one or more of the associated listed items and all possible combinations, and includes such combinations.

[0017] Please see below. Figure 1 , Figure 1 The flowchart of a congestion self-recovery method for a private network dialing test task provided in an embodiment of the present invention specifically includes steps S101 to S107.

[0018] S101. Connect to the test task source and perform standardized queuing to obtain the initial task queue; S102. Calculate the queue length based on the initial task queue, compare the queue length with a preset congestion trigger variable, and obtain a congestion determination result; S103. Use the congestion determination result to generate a target pointer and obtain a target task pointer object; S104. Perform a test according to the test task configuration pointed to by the target task pointer object to obtain a test execution record set; S105. Perform queue synchronization update on the dial test execution record set, and dequeue the task pointed to by the target task pointer object from the initial task queue to obtain the updated task queue. S106. Calculate the updated queue length based on the updated task queue; S107. When the updated queue length is greater than or equal to the congestion trigger variable, a target pointer is generated based on the updated task queue to obtain a new target task pointer object. This process is repeated until the updated queue length is less than the congestion trigger variable, at which point a scheduling termination indication is output.

[0019] In step S101, the test task source is accessed, and the test tasks generated by the scheduling center on a timed or on-demand basis are validated and formatted. The queue execution strategy is set to first-in-first-out, and the standardized test task objects are written sequentially to the tail of the task queue maintained by the queue manager to obtain the initial task queue.

[0020] In one embodiment, step S101 includes: Instantiate the queue manager to obtain an empty queue object; Access the test task scheduling center to generate test tasks on a scheduled or on-demand basis, and obtain the original test task object; Parse the attributes of the original object of the dial-up test task to obtain the task attribute set; wherein, the task attribute set includes the dial-up test private network name, dial-up test type, dial-up test address and dial-up test cycle number; The task attribute set is normalized to obtain a standardized attribute set; The standardized attribute set is encapsulated into an object, and the queue execution strategy is set to first-in-first-out to obtain a standardized test task object; The standardized test task objects are enqueued and pushed to the tail of the empty queue objects to obtain the initial task queue.

[0021] In this embodiment, the queue manager is instantiated, the running parameters of the queue management module are initialized, and an empty queue object is created. The queue execution strategy is preset to First-In-First-Out (FIFO), and metadata related to the queue (including queue identifier, creation timestamp, capacity threshold, and length counter) is registered to ensure that all subsequent enqueue / dequeue operations follow a unified timing and consistency rule. Then, the testing task source is connected, and the testing task scheduling center generates testing tasks on a scheduled or on-demand basis, obtaining the original testing task object (carrying original fields and a generation timestamp). The queue manager receives this original object through message subscription or RPC interface, and assigns a temporary access number upon successful reception, preparing for the attribute parsing process. According to system design requirements, all newly generated testing tasks are pushed to the tail of the task queue to match the FIFO strategy.

[0022] Furthermore, the original objects of the dial-up testing tasks are parsed to extract and construct a task attribute set. This task attribute set includes at least: the dial-up testing network name, the dial-up testing type, the dial-up testing address, and the dial-up testing cycle number. During the parsing process, field names are mapped and validated, and alarms and default filling strategies are implemented for missing or redundant fields to ensure the integrity and availability of the attribute set. The task attribute set is then normalized to obtain a standardized attribute set. Normalization includes, but is not limited to: unifying the encoding and aliases for the dial-up testing network name; performing controlled enumeration mapping for the dial-up testing type (e.g., based on ping, http, ftp, etc.); performing format and validity checks on the dial-up testing address (e.g., IP / domain name regular expression checks and port range checks); and normalizing the dial-up testing cycle number to a non-negative integer and binding it to a generated timestamp; if necessary, the comparison before and after normalization is recorded for auditing and traceability.

[0023] After normalization, the standardized attribute set is encapsulated into an object to generate a standardized probing task object. The encapsulation includes: a unique task identifier, a standardized attribute set, a FIFO execution policy flag, a creation / update timestamp, an idempotent control flag, and a minimal configuration index required for execution. The execution policy is explicitly specified as First-In-First-Out (FIFO) to maintain consistency with the overall system scheduling constraints. Finally, an enqueue operation is performed on the standardized probing task object: the object is written to the tail of the queue maintained by the queue manager, and the queue length counter L = len(Q) is updated. This results in an initial task queue including newly enqueued tasks, providing a unified data foundation for subsequent queue length calculations, congestion assessments, and target task pointer generation.

[0024] In step S102, the length of the initial task queue is calculated to obtain the queue length value; the length value is compared with the preset congestion trigger variable, and a congestion determination result is generated based on the comparison relationship to indicate whether the current queue is in a congested state.

[0025] In one embodiment, prior to step S102, the following steps are included: The initial task queue is subjected to key extraction to obtain a set of classification keys; The type of the classification key set is set to obtain the attribute definition object; Based on the attribute definition object, key-value aggregation is performed in the initial task queue to construct a basic key tuple, and the dialing cycle number of the task object matching the basic key tuple is collected to obtain the task pointer attribute set. The task pointer attribute set is encapsulated into an object to obtain a dialing task pointer object; Bind the pointer to the test task pointer object with a pointer rule to obtain a test task pointer object with a pointer rule.

[0026] In this embodiment, each testing task object in the initial task queue is scanned to extract three categories of classification keys: "testing network name," "testing type," and "testing address," resulting in a set of classification keys. Simultaneously, the testing cycle attribute associated with these three keys is identified and extracted. The testing cycle is an array type used to carry the sequence number information of one or more similar tasks under different testing cycles. The classification key set is then further categorized, and attribute definition objects are established: the testing network name is defined as a controlled string or encoded enumeration; the testing type is defined as a controlled enumeration (e.g., ping, http); the testing address is defined as an address string and bound with validity verification rules; and the testing cycle attribute is defined as an integer array with constraints on non-negativity and order.

[0027] After completing the type setting, key-value aggregation is performed on the initial task queue based on the attribute definition object: using (test network name, test type, test address) as the basic key tuple, tasks with the same key in the queue are merged, and the test cycle number of matching task objects is collected one by one to generate a cycle number list indexed by key tuple; for each key tuple, a task pointer attribute set including "network name, type, address, and test cycle array" is obtained, and the position range of the key tuple in the queue and the time identifier appended to the tail of the queue are recorded to ensure consistency with the first-in-first-out (FIFO) strategy. The task pointer attribute set is encapsulated into an object to construct a test task pointer object. This pointer object includes at least: key tuple identifier, test cycle array, position range, reference index to the execution configuration, and pointer mode placeholder field; among them, the test cycle array is used to indicate one or more similar task instances that the pointer can point to, and the position range is used to limit the operable window in the queue to ensure that subsequent dequeueing and status updates are traceable and idempotent.

[0028] Finally, pointer rules are bound to the test task pointer objects to obtain test task pointer objects with pointer rules. The pointer rules constrain behavior based on queue congestion status: when no congestion occurs, the pointer object only points to the first test task at the head of the queue; when congestion occurs, the pointer object points to multiple tasks in the queue with the same "private network name, test type, and test address," and selects one or more corresponding tasks as the pointer target using their test cycle array. Through the step-by-step processing of key extraction, type setting, key-value aggregation, object encapsulation, and rule binding, the initial task queue is structurally merged and represented as pointers, providing a unified and directly callable data carrier for subsequent steps of congestion determination and scheduling execution based on queue length.

[0029] In one embodiment, the step of defining the preset congestion trigger variable includes: The preset initial parameter set is subjected to constraint normalization, and the congestion threshold candidate set and self-recovery coefficient candidate set are extracted respectively. The congestion threshold candidate set is truncated to obtain a congestion trigger variable; wherein the congestion trigger variable is an integer and is greater than or equal to a first preset value; The candidate set of self-recovery coefficients is pruned to obtain the self-recovery coefficients; wherein the self-recovery coefficients are greater than a second preset value and less than or equal to a third preset value.

[0030] In this embodiment, a preset initial parameter set is constructed. This initial parameter set is derived from the system default configuration and historical operation statistics, including raw quantities used to characterize the queue load threshold and self-recovery strength. The initial parameter set undergoes constraint normalization, i.e., unifying the dimensions, removing outliers, and completing type verification. It is then split and extracted according to variable semantics to obtain a congestion threshold candidate set and a self-recovery coefficient candidate set. Next, interval truncation and type solidification are performed on the congestion threshold candidate set: a first preset value is initially set based on the threshold safety boundary, and values ​​in the candidate set smaller than this boundary are adjusted up to the first preset value. Simultaneously, continuous values ​​are integerized to obtain the congestion trigger variable α; where α is an integer and satisfies α ≥ the first preset value. In this embodiment, to meet the minimum congestion identifiable granularity of the dialing queue, the first preset value is 2, i.e., α ≥ 2 and is an integer. Next, interval pruning and closed-interval mapping are performed on the candidate set of self-recovery coefficients: a second preset value and a third preset value are set as the lower and upper boundaries, respectively. Values ​​in the candidate set that exceed the boundaries are pruned back into the closed interval to form the self-recovery coefficient β, ensuring that the second preset value < β ≤ the third preset value. In this embodiment, to ensure that the self-recovery ratio has both strict positivity and upper bound reachability, the second preset value is set to 0 and the third preset value is set to 1, i.e., 0 < β ≤ 1. Finally, the interval-processed α and β are written together into the scheduling configuration context, and persistently stored along with the generation timestamp and version number. Read-only references are made available for subsequent scheduling stages, thereby providing a stable and well-defined parameter basis for congestion determination and self-recovery strategy mapping based on queue length.

[0031] In step S103, target pointer generation is performed based on the congestion determination result: when there is no congestion, a target task pointer object is constructed that points only to a single task at the head of the queue; when congestion is determined to exist, similar tasks in the queue are merged according to preset pointing rules, and a target task pointer object that can point to a subset of similar tasks is constructed. The pointer object carries the pointing range and the configuration index required for execution.

[0032] In step S104, execution parameters are sent to the corresponding testing terminal according to the testing task configuration pointed to by the target task pointer object, completing the protocol initiation, testing process control and result collection, and obtaining a testing execution record set including result code, timestamp and associated task identifier.

[0033] In step S105, the queue synchronization update is performed on the test execution record set, the corresponding task status and execution metadata within the pointing range are written in a consistent manner, and the task pointed to by the target task pointer object is dequeued from the initial task queue to obtain the updated task queue; at the same time, logs and index information related to this scheduling are maintained for subsequent cyclical use.

[0034] In step S106, the queue length is recalculated based on the updated task queue to obtain the updated queue length value, which is used as the input for the next loop decision.

[0035] In step S107, the updated queue length is compared with the congestion trigger variable: when the updated queue length is greater than or equal to the congestion trigger variable, the execution target pointer generation is returned to obtain a new target task pointer object, and the loop continues; when the updated queue length is less than the congestion trigger variable, a scheduling termination indication is generated and output, and the current round of scheduling process ends.

[0036] In one embodiment, step S107 includes: The updated queue length is compared with the congestion trigger variable to obtain a congestion determination signal; By combining the updated task queue with the test execution record set, time window rate statistics are performed to obtain the system task generation speed and terminal processing speed, and a rate comparison result is generated. The congestion level is determined by comparing the congestion determination signal with the rate. When the updated queue length is greater than or equal to the congestion trigger variable and the system task generation speed is greater than the terminal processing speed, a severe congestion identifier is obtained. The severe congestion identifier is mapped using a policy to obtain a new target task pointer object.

[0037] In this embodiment, the updated queue length is denoted as L′. L′ is compared with a preset congestion trigger variable α to obtain a congestion determination signal. When L′≥α, it indicates that the system's task generation rate may be greater than the terminal's actual task processing rate, and the congestion of the probed tasks has a tendency to continue to worsen and may exceed the system's tolerance limit. At this time, the congestion response process needs to be initiated. Subsequently, based on the updated task queue and the probed execution record set formed in the previous or current round, rate statistics are performed according to a unified time window: the system task generation rate (number of new tasks per unit time) is calculated using the task enqueue timestamp, and the terminal processing rate (number of tasks completed per unit time) is calculated using the task completion timestamp, to obtain a rate comparison result. Then, the congestion determination signal and the rate comparison result are combined for congestion level determination: when L′≥α and the system task generation rate is greater than the terminal processing rate, a severe congestion flag is generated to indicate the pointer pointing strategy that needs to be adjusted. Finally, a policy mapping is performed on the severe congestion identifier, and a new target task pointer object is generated according to the established mapping relationship: the pointer is preferentially pointed to the subset of similar tasks in the queue that have the same "private network name, dialing test type, dialing test address", and the range of intervals that need to be processed first is determined according to the pointer configuration; thus forming a new pointer object that can be called by the next round of steps, so as to adjust the set of dialing test tasks to be executed in a timely manner in the congestion scenario, and complete the closed-loop control from congestion detection to pointer reconfiguration.

[0038] In one embodiment, the step of performing policy mapping on the heavily congested identifier to obtain a new target task pointer object includes: The updated task queue is filtered according to similar conditions to obtain a set of similar tasks; The total number of tasks is obtained by counting and statistically analyzing the set of similar tasks. The total number of tasks is calculated by combining the self-recovery coefficient to obtain the testing cycle; wherein the result of the testing cycle is an integer rounded down. The dialing cycle is interval-based to determine the dialing tasks within a preset interval, thereby obtaining a sequence of dialing tasks within the interval. The test is performed using the test task configuration content in the test task sequence within the interval, and the set of executed tasks is obtained. The set of executed tasks is processed by pointer removal, and a new target task pointer object is output.

[0039] In this embodiment, the updated task queue is filtered based on similar conditions: tasks with the same key are selected from the queue using "test network name, test type, test address" as the aggregation key, resulting in a set of similar tasks. In an example scenario, similar conditions can be represented as "network name is A, test type is ping, test address is 8.8.8.8", thus obtaining a set representation of this type of task. The set of similar tasks is then counted to obtain the total number of tasks T, and the upper bound Ax of the test cycle is calculated based on the self-recovery coefficient β, where Ax is obtained by rounding down the result of T×β, and Ax is an integer.

[0040] After obtaining Ax, the testing cycle is located within a specific interval: using the cycle number arranged in the queue order within the same task set as an index, the testing tasks located within a preset interval are determined. This preset interval is defined as from the first cycle to the Axth cycle, forming a sequence of testing tasks within the interval (example representation: A1…Ax). Next, testing is triggered item by item according to the configuration of each testing task in the interval's sequence, recording execution parameters and return codes. This results in a set of executed tasks, and the task status and execution metadata corresponding to this set are synchronously written to the queue manager to maintain synchronization with the queue view. Figure 1 To.

[0041] After completing the interval testing, a pointer removal process is performed on the set of executed tasks. This involves dequeuing all queue elements pointed to by the current target task pointer object, clearing or updating their positional references and period indices in the pointer object, and outputting a new target task pointer object. The new target task pointer object carries a class key identifier and the remaining available period index (if there are still unprocessed subsequent periods), thereby completing the proportional truncation and continuous scheduling of class-type task intervals in heavily congested scenarios.

[0042] In one embodiment, step S107 further includes: The updated queue length is compared with the congestion trigger variable to obtain the loop determination result; Based on the loop determination result, when no congestion occurs, the target task pointer object is pointed to the first task in the initial task queue to obtain the currently pointed-to task; The currently targeted task is tested according to the corresponding test configuration to obtain an execution completion identifier; Based on the execution completion identifier, the status of the currently pointed-to task is modified to "executed" and removed from the initial task queue to obtain the updated task queue; Based on the updated task queue, the target task pointer object is adjusted to point to a subsequent task, resulting in a new target task. Based on the new target task return execution comparison determination, until the updated queue length is less than the congestion trigger variable, then output a scheduling termination indication.

[0043] In this embodiment, after completing a queue synchronization update, the scheduling center obtains the updated queue length L′, where L′ = len(Q). L′ is compared with the congestion trigger variable α to obtain a loop determination result. When L′ < α, it indicates that the current testing task is not congested. At this time, the target task pointer object is reset to point only to the first task in the initial task queue to obtain the currently pointed-to task. Subsequently, according to the testing configuration carried by the currently pointed-to task (including the testing private network name, testing type, testing address, and testing cycle number), a testing instruction is sent to the corresponding terminal, and the return code, timestamp, and associated identifier are collected to generate an execution completion identifier. Based on the execution completion identifier, the status of the currently pointed-to task is modified to "executed" and removed from the initial task queue to obtain the updated task queue Q. Based on this, according to the FIFO strategy, the target task pointer object is sequentially pointed to subsequent tasks to obtain a new pointed-to task, and the execution comparison determination process is returned to enter the next round of testing and dequeueing loop.

[0044] For ease of understanding, in an example scenario: when the queue is not congested, the pointer first points to the first test task at the head of the queue (e.g., task A1 of private network A); after task A1 is completed, it is immediately marked as executed and removed from the queue; then the task pointer is adjusted to point to the subsequent task (e.g., task B1 of private network B), and the process of execution, updating and judgment continues as described above; when the loop progresses to the point where the updated queue length is recalculated and satisfies L′<α and there are no subsequent test tasks or the preset termination condition is met, a scheduling termination indication is output, and the current round of scheduling ends.

[0045] A scheduling system management platform is deployed in a public cloud environment, using a B / S architecture. Several test terminals are deployed within the target area. These terminals communicate with the scheduling system via HTTP to obtain test tasks and report their status.

[0046] Scenario setting: Terminal A in a certain province went offline due to a temporary network anomaly. After it came back online, it started fetching tasks. At this time, the length of the task queue Q in the scheduling center surged to L=50; the congestion trigger variable was preset to α=10, and the self-recovery coefficient was preset to β=0.5.

[0047] The processing procedure is as follows: The scheduling center detects that L=50>α=10 and triggers congestion handling. The current task at the head of the queue is a task for private network A, Ping type, address 10.0.0.1, with a cycle number of 1. Traverse the queue and find all 20 similar tasks (private network A, Ping, 10.0.0.1) (sequence numbers 1 to 20). Calculate N_max=⌊20×0.5⌋=10, and set the task pointer P to point to the 10 tasks with sequence numbers 1 to 10. The scheduling center notifies the terminal to execute one (private network A, Ping, 10.0.0.1) operation (this result represents the processing of task requests with sequence numbers 1 to 10), and then marks the above 10 tasks as completed and removes them from the queue.

[0048] At this point, the queue length drops to L=40. Since 40>10, congestion handling continues. The new header task is (private network A, Ping, 10.0.0.1) with a cycle number of 11; after traversal, it is confirmed that there are 10 remaining tasks of the same type (sequence numbers 11 to 20). N_max is calculated again as ⌊10×0.5⌋=5, and the task pointer P is set to point to the 5 tasks with sequence numbers 11 to 15; after completing the corresponding dialing test, these 5 tasks are removed, and the queue length is updated to L=35.

[0049] The above process repeats with the same logic until the same type of task (Ping 10.0.0.1 on private network A) is completed, or the queue length drops below the threshold (L < α). When L < α is satisfied, the system proceeds along the non-congestion branch and begins processing other private networks or other types of tasks. The above implementation case fully demonstrates the self-recovery scheduling process based on the self-recovery coefficient β to proportionally truncate, batch execute, and continuously dequeue tasks within the same task range under conditions of severe congestion.

[0050] In summary, this invention belongs to the field of 5G private network end-to-end testing technology. It proposes a task pointer scheduling mechanism to address the congestion problem of private network end-to-end testing tasks: the testing terminal does not directly obtain tasks one by one, but the scheduling center dynamically adjusts the testing task object pointed to by the pointer by combining the congestion trigger variable α and the self-recovery coefficient β. This allows for precise control over the triggering timing of the congestion strategy and the expected recovery task range, so as to quickly and efficiently resolve testing task congestion caused by terminal or network anomalies.

[0051] Compared to existing terminal call scheduling strategies, this invention offers the following advantages: First, high flexibility: By introducing two configurable parameters, α and β, the timing of congestion triggering and the recovery coverage can be flexibly set according to the scenario. Second, high efficiency: By adjusting the self-recovery coefficient β, congestion can be resolved within one to two scheduling cycles, significantly shortening the recovery time. Third, good adaptability: When no congestion occurs, it has zero intrusion into the existing scheduling process and does not generate additional overhead; once congestion occurs, it automatically intervenes and implements pointer-based batch processing, ensuring stable operation of the system under different load conditions.

[0052] Combination Figure 2 As shown, Figure 2 This is a schematic block diagram of a private network dialing test task congestion self-recovery device provided in an embodiment of the present invention. The private network dialing test task congestion self-recovery device 200 includes: The data access unit 201 is used to access the test task source and perform standardized queuing processing to obtain the initial task queue. The data comparison unit 202 is used to calculate the queue length based on the initial task queue, compare the queue length with a preset congestion trigger variable, and obtain a congestion determination result. Pointer generation unit 203 is used to generate a target pointer using the congestion determination result to obtain a target task pointer object; The test processing unit 204 is used to perform test according to the test task configuration pointed to by the target task pointer object, and obtain a test execution record set; The queue update unit 205 is used to perform queue synchronization update on the test execution record set and dequeue the task pointed to by the target task pointer object from the initial task queue to obtain the updated task queue. The length update unit 206 is used to calculate the updated queue length based on the updated task queue. The scheduling output unit 207 is used to generate a new target task pointer object based on the updated task queue return when the updated queue length is greater than or equal to the congestion trigger variable, and continuously loop until the updated queue length is less than the congestion trigger variable, and then output a scheduling termination indication.

[0053] In this embodiment, the data access unit 201 accesses the test task source and performs standardized queuing processing to obtain an initial task queue; the data comparison unit 202 calculates the queue length based on the initial task queue, compares the queue length with a preset congestion trigger variable, and obtains a congestion determination result; the pointer generation unit 203 uses the congestion determination result to generate a target pointer to obtain a target task pointer object; the test processing unit 204 performs test according to the test task configuration pointed to by the target task pointer object to obtain a test execution record set; the queue update unit 205 performs queue synchronization update on the test execution record set and dequeues the task pointed to by the target task pointer object from the initial task queue to obtain an updated task queue; the length update unit 206 calculates the updated queue length based on the updated task queue; the scheduling output unit 207, when the updated queue length is greater than or equal to the congestion trigger variable, returns the updated task queue to generate a target pointer to obtain a new target task pointer object, and continuously loops until the updated queue length is less than the congestion trigger variable, and then outputs a scheduling termination indication.

[0054] In one embodiment, the data access unit 201 is specifically used for: Instantiate the queue manager to obtain an empty queue object; Access the test task scheduling center to generate test tasks on a scheduled or on-demand basis, and obtain the original test task object; Parse the attributes of the original object of the dial-up test task to obtain the task attribute set; wherein, the task attribute set includes the dial-up test private network name, dial-up test type, dial-up test address and dial-up test cycle number; The task attribute set is normalized to obtain a standardized attribute set; The standardized attribute set is encapsulated into an object, and the queue execution strategy is set to first-in-first-out to obtain a standardized test task object; The standardized test task objects are enqueued and pushed to the tail of the empty queue objects to obtain the initial task queue.

[0055] In one embodiment, the private network dialing test task congestion self-recovery device 200 is further specifically used for: The initial task queue is subjected to key extraction to obtain a set of classification keys; The type of the classification key set is set to obtain the attribute definition object; Based on the attribute definition object, key-value aggregation is performed in the initial task queue to construct a basic key tuple, and the dialing cycle number of the task object matching the basic key tuple is collected to obtain the task pointer attribute set. The task pointer attribute set is encapsulated into an object to obtain a dialing task pointer object; Bind the pointer to the test task pointer object with a pointer rule to obtain a test task pointer object with a pointer rule.

[0056] In one embodiment, the data comparison unit 202 is specifically used for: The preset initial parameter set is subjected to constraint normalization, and the congestion threshold candidate set and self-recovery coefficient candidate set are extracted respectively. The congestion threshold candidate set is truncated to obtain a congestion trigger variable; wherein the congestion trigger variable is an integer and is greater than or equal to a first preset value; The candidate set of self-recovery coefficients is pruned to obtain the self-recovery coefficients; wherein the self-recovery coefficients are greater than a second preset value and less than or equal to a third preset value.

[0057] In one embodiment, the scheduling output unit 207 is specifically used for: The updated queue length is compared with the congestion trigger variable to obtain a congestion determination signal; By combining the updated task queue with the test execution record set, time window rate statistics are performed to obtain the system task generation speed and terminal processing speed, and a rate comparison result is generated. The congestion level is determined by comparing the congestion determination signal with the rate. When the updated queue length is greater than or equal to the congestion trigger variable and the system task generation speed is greater than the terminal processing speed, a severe congestion identifier is obtained. The severe congestion identifier is mapped using a policy to obtain a new target task pointer object.

[0058] In one embodiment, the scheduling output unit 207 is further specifically used for: The updated task queue is filtered according to similar conditions to obtain a set of similar tasks; The total number of tasks is obtained by counting and statistically analyzing the set of similar tasks. The total number of tasks is calculated with the self-recovery coefficient to obtain the testing cycle; wherein the result of the testing cycle is an integer rounded down. The dialing cycle is interval-based to determine the dialing tasks within a preset interval, thereby obtaining a sequence of dialing tasks within the interval. The test is performed using the test task configuration content in the test task sequence within the interval, and the set of executed tasks is obtained. The set of executed tasks is processed by pointer removal, and a new target task pointer object is output.

[0059] In one embodiment, the scheduling output unit 207 is further specifically used for: The updated queue length is compared with the congestion trigger variable to obtain the loop determination result; Based on the loop determination result, when no congestion occurs, the target task pointer object is pointed to the first task in the initial task queue to obtain the currently pointed-to task; The currently targeted task is tested according to the corresponding test configuration to obtain an execution completion identifier; Based on the execution completion identifier, the status of the currently pointed-to task is modified to "executed" and removed from the initial task queue to obtain the updated task queue; Based on the updated task queue, the target task pointer object is adjusted to point to a subsequent task, resulting in a new target task. Based on the new target task return execution comparison determination, until the updated queue length is less than the congestion trigger variable, then output a scheduling termination indication.

[0060] Since the embodiments of the apparatus and the embodiments of the method correspond to each other, please refer to the description of the embodiments of the method for the embodiments of the apparatus, which will not be repeated here.

[0061] This invention also provides a computer-readable storage medium storing a computer program thereon, which, when executed, can perform the steps provided in the above embodiments. The storage medium may include various media capable of storing program code, such as a USB flash drive, a portable hard drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk.

[0062] This invention also provides a computer device, which may include a memory and a processor. The memory stores a computer program, and when the processor calls the computer program in the memory, it can implement the steps provided in the above embodiments. Of course, the computer device may also include various network interfaces, a power supply, a graphics card, etc., to utilize the graphics card's performance to operate the model, such as for inference and training.

[0063] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For the systems disclosed in the embodiments, since they correspond to the methods disclosed in the embodiments, the descriptions are relatively simple; relevant parts can be referred to in the method section. It should be noted that those skilled in the art can make various improvements and modifications to this application without departing from the principles of this application, and these improvements and modifications also fall within the protection scope of the claims of this application.

[0064] It should also be noted that, in this specification, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

Claims

1. A method for self-recovery from congestion in a dedicated network dial-up testing task, characterized in that, include: Connect to the test task source and perform standardized queuing to obtain the initial task queue; The queue length is calculated based on the initial task queue, and the queue length is compared with a preset congestion trigger variable to obtain a congestion determination result. The congestion determination result is used to generate a target pointer, resulting in a target task pointer object. Perform a test based on the test task configuration pointed to by the target task pointer object to obtain a test execution record set; The queue of the test execution record set is updated synchronously, and the task pointed to by the target task pointer object is dequeued from the initial task queue to obtain the updated task queue. The updated queue length is calculated based on the updated task queue; When the updated queue length is greater than or equal to the congestion trigger variable, a new target task pointer object is generated based on the updated task queue. This process is repeated until the updated queue length is less than the congestion trigger variable, at which point a scheduling termination indication is output. The definition steps of the preset congestion trigger variable include: performing constraint normalization on a preset initial parameter set to extract a congestion threshold candidate set and a self-recovery coefficient candidate set; truncating the congestion threshold candidate set to obtain a congestion trigger variable; wherein the congestion trigger variable is an integer and is greater than or equal to a first preset value, the first preset value being 2; truncating the self-recovery coefficient candidate set to obtain a self-recovery coefficient; wherein the self-recovery coefficient is greater than a second preset value and less than or equal to a third preset value, the second preset value being 0 and the third preset value being 1. When the updated queue length is greater than or equal to the congestion trigger variable, generating a new target task pointer object based on the updated task queue includes: comparing the updated queue length with the congestion trigger variable to obtain a congestion determination signal; using the updated task queue in conjunction with the dialing execution record set to perform time window rate statistics to obtain the system task generation rate and terminal processing rate, and generating a rate comparison result; wherein, the system task generation rate is calculated based on the task enqueue timestamp and the number of new tasks added per unit time, and the terminal processing rate is calculated based on the task completion timestamp and the number of tasks completed per unit time; determining the congestion level by comparing the congestion determination signal with the rate comparison result; when the updated queue length is greater than or equal to the congestion trigger variable and the system task generation rate is greater than the terminal processing rate, a severe congestion identifier is obtained; and performing policy mapping on the severe congestion identifier to obtain a new target task pointer object. The step of mapping the severe congestion identifier to obtain a new target task pointer object includes: filtering the updated task queue based on similar conditions to obtain a set of similar tasks; wherein, the similar condition filtering is to select tasks with the same key from the updated task queue using the dial-up network name, dial-up type, and dial-up address as aggregation keys; counting the set of similar tasks to obtain the total number of tasks; calculating the total number of tasks with the self-recovery coefficient to obtain the dial-up testing period; wherein, the dial-up testing period is obtained by rounding down the product of the total number of tasks and the self-recovery coefficient, and is an integer; and performing interval positioning on the dial-up testing period to determine whether the dial-up testing period is within a preset interval. The test task is performed to obtain a sequence of test tasks within a given interval. The interval location is indexed by the cycle number arranged in the queue order within the set of similar tasks. The preset interval extends from the first cycle to the end of the test cycle. Tests are performed using the test task configuration content within the interval's sequence to obtain a set of executed tasks. A pointer removal process is then performed on the executed task set to output a new target task pointer object. This pointer removal process involves dequeuing all queue elements pointed to by the current target task pointer object and clearing or updating their positional references and cycle indices within the pointer object. The new target task pointer object carries a similar key identifier and a remaining available cycle index.

2. The method for self-recovery from congestion in a dedicated network dialing test task according to claim 1, characterized in that, The access test task source is processed and standardized queuing is performed to obtain an initial task queue, including: Instantiate the queue manager to obtain an empty queue object; Access the test task scheduling center to generate test tasks on a scheduled or on-demand basis, and obtain the original test task object; Parse the attributes of the original object of the dial-up test task to obtain the task attribute set; wherein, the task attribute set includes the dial-up test private network name, dial-up test type, dial-up test address and dial-up test cycle number; The task attribute set is normalized to obtain a standardized attribute set; The standardized attribute set is encapsulated into an object, and the queue execution strategy is set to first-in-first-out to obtain a standardized test task object; The standardized test task objects are enqueued and pushed to the tail of the empty queue objects to obtain the initial task queue.

3. The method for self-recovery from congestion in a dedicated network dialing test task according to claim 1, characterized in that, Before calculating the queue length based on the initial task queue, comparing the queue length with a preset congestion trigger variable, and obtaining the congestion determination result, the following steps are included: The initial task queue is subjected to key extraction to obtain a set of classification keys; The type of the classification key set is set to obtain the attribute definition object; Based on the attribute definition object, key-value aggregation is performed in the initial task queue to construct a basic key tuple, and the dialing cycle number of the task object matching the basic key tuple is collected to obtain the task pointer attribute set. The task pointer attribute set is encapsulated into an object to obtain a dialing task pointer object; Bind the pointer to the test task pointer object with a pointer rule to obtain a test task pointer object with a pointer rule.

4. The method for self-recovery from congestion in a dedicated network dialing test task according to claim 1, characterized in that, The process of continuously looping until the updated queue length is less than the congestion trigger variable, and then outputting a scheduling termination indication, includes: The updated queue length is compared with the congestion trigger variable to obtain the loop determination result; Based on the loop determination result, when no congestion occurs, the target task pointer object is pointed to the first task in the initial task queue to obtain the currently pointed-to task; The currently targeted task is tested according to the corresponding test configuration to obtain an execution completion identifier; Based on the execution completion identifier, the status of the currently pointed-to task is modified to "executed" and removed from the initial task queue to obtain the updated task queue; Based on the updated task queue, the target task pointer object is adjusted to point to a subsequent task, resulting in a new target task. Based on the new target task return execution comparison determination, until the updated queue length is less than the congestion trigger variable, then output a scheduling termination indication.

5. A congestion self-recovery device for dedicated network dialing tasks, characterized in that, include: The data access unit is used to access the test task source and perform standardized queuing processing to obtain the initial task queue. The data comparison unit is used to calculate the queue length based on the initial task queue, compare the queue length with a preset congestion trigger variable, and obtain a congestion determination result. The definition step of the preset congestion trigger variable includes: performing constraint normalization on a preset initial parameter set to extract a congestion threshold candidate set and a self-recovery coefficient candidate set; truncating the congestion threshold candidate set to obtain a congestion trigger variable, wherein the congestion trigger variable is an integer and greater than or equal to a first preset value, where the first preset value is 2; and truncating the self-recovery coefficient candidate set to obtain a self-recovery coefficient, wherein the self-recovery coefficient is greater than a second preset value and less than or equal to a third preset value, where the second preset value is 0 and the third preset value is 1. A pointer generation unit is used to generate a target pointer using the congestion determination result, thereby obtaining a target task pointer object; The test processing unit is used to perform test according to the test task configuration pointed to by the target task pointer object, and obtain a test execution record set; The queue update unit is used to perform queue synchronization update on the test execution record set and dequeue the task pointed to by the target task pointer object from the initial task queue to obtain the updated task queue. The length update unit is used to calculate the updated queue length based on the updated task queue. The scheduling output unit is configured to generate a new target task pointer object based on the updated task queue return when the updated queue length is greater than or equal to the congestion trigger variable, and continuously loop until the updated queue length is less than the congestion trigger variable, at which point it outputs a scheduling termination indication; wherein, the step of generating a new target task pointer object based on the updated task queue return when the updated queue length is greater than or equal to the congestion trigger variable includes: comparing the updated queue length with the congestion trigger variable to obtain a congestion determination signal; and using the updated task queue in conjunction with the... The system performs time window rate statistics on the test execution record set to obtain the system task generation rate and terminal processing rate, and generates a rate comparison result. The system task generation rate is calculated based on the number of new tasks added per unit time using the task enqueue timestamp, and the terminal processing rate is calculated based on the number of tasks completed per unit time using the task completion timestamp. The congestion determination signal is compared with the rate comparison result to determine the congestion level. When the updated queue length is greater than or equal to the congestion trigger variable and the system task generation rate is greater than the terminal processing rate, a severe congestion flag is obtained. The severe congestion flag is then mapped using a policy to obtain a new target task pointer object. The process involves: mapping the target task pointer object to a new target task object; filtering the updated task queue based on similar conditions to obtain a set of similar tasks, wherein the filtering is performed using the test network name, test type, and test address as aggregation keys, and selecting tasks with the same key from the updated task queue; counting the set of similar tasks to obtain the total number of tasks; calculating the test cycle by multiplying the total number of tasks by the self-recovery coefficient, wherein the test cycle is obtained by rounding down the product of the total number of tasks and the self-recovery coefficient, and is an integer; and performing interval positioning on the test cycle to determine the test tasks whose test cycles fall within a preset interval. The task sequence within the interval is determined by indexing the period number arranged in the queue order within the set of similar tasks. The preset interval is from the first cycle to the end of the testing cycle. The testing is performed using the testing task configuration content in the task sequence within the interval to obtain a set of executed tasks. The set of executed tasks is then processed by pointer removal, and a new target task pointer object is output. The pointer removal process involves dequeuing all queue elements pointed to by the current target task pointer object from the queue and clearing or updating their position references and cycle indices in the pointer object. The new target task pointer object carries a similar key identifier and the remaining available cycle index.

6. A computer device, characterized in that, The method includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it implements the private network dialing test task congestion self-recovery method as described in any one of claims 1 to 4.

7. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program, which, when executed by a processor, implements the private network dialing test task congestion self-recovery method as described in any one of claims 1 to 4.

Images