An agent task cooperative control method and system based on network service

Abstract

This invention relates to the field of task scheduling technology, specifically to a method and system for intelligent agent task collaborative control based on network services. The method includes the following steps: obtaining round identifiers, preceding reference markers, interface addresses, and plug-in service identifiers; calculating round differences to generate scheduling segments; detecting heartbeat latency, network card queuing counts, resource usage, and concurrency to form an admission list; filtering permissions based on the remaining number of plug-in attempts, the number of admission attempts, and the number of call records; generating batch instructions by combining resource differences and the number of attempts quotient; and writing dispatch instructions according to network priority. In this invention, by incorporating round dependencies, runtime load, permission reserves, and network priority into the same scheduling link, entry judgment, permission filtering, batch size, and dispatch direction are mutually verified, reducing batch coarseness, resource conflicts, permission overdraft, and redispatch delays. This improves the stability, continuity, and controllability of cross-interface plug-in task collaboration and enhances the traceability of multi-round task flow interface calls and plug-in service connections.

Description

Technical Field

[0001] This invention relates to the field of task scheduling technology, and in particular to a method and system for intelligent agent task collaborative control based on network services. Background Technology

[0002] The field of task scheduling technology mainly involves splitting, sorting, assigning, tracking, and reassigning tasks to be processed according to task type, task priority, execution deadline, data scale, personnel load, resource status, dependency relationship, and permission conditions. Its core aspects include task queue establishment, task batch division, execution object matching, execution order determination, task status recording, abnormal task recovery, and setting operation boundaries for different participating roles. It typically forms a complete scheduling process around task source, task content, task executor, task flow nodes, and task allocation rules. The traditional data annotation and distribution intelligent scheduling and permission management system refers to a system that generates annotation tasks for datasets such as images, text, voice, or video awaiting annotation, based on projects, batches, sample quantities, annotation types, and review requirements. Tasks are then distributed according to the annotator's account, role, annotable categories, historical annotation records, current pending tasks, project deadlines, and task priorities. Typically, a data batch list records samples to be annotated, annotation templates limit label names, label levels, and fields, an account / role table distinguishes the operational scope of administrators, annotators, and reviewers, and a task queue stores statuses such as pending, in progress, pending review, returned, and completed. The system completes the distribution and permission management of data annotation tasks through steps such as sample locking, task acquisition, annotation submission, review confirmation, return for modification, and reassignment.

[0003] Traditional data labeling and distribution relies on data batch lists and account role tables as the main framework. Task flow revolves around receiving, submitting, reviewing, returning, and redistributing. Task splitting is biased towards sample quantity, labeling type, personnel role, number of pending tasks, and deadline. The scheduling entry point has a weak correlation with operating resources, and the dependency of interface addresses and service identifiers is difficult to divide with task rounds. Gateway load, network congestion, processor usage, memory pressure, and concurrency accumulation are easily exposed after distribution. Permission reserves are disconnected from call records, resulting in coarse task batching, unbalanced matching of execution objects, and delayed abnormal recovery and redistribution. Summary of the Invention

[0004] To achieve the above objectives, the present invention adopts the following technical solution: a network service-based intelligent agent task collaborative control method, comprising the following steps:

[0005] S1: The user terminal obtains the task round identifier, the preceding task reference marker, the target business interface address and the plug-in service identifier, calculates the round difference, divides the target business interface address and plug-in service identifier dependency according to the round difference, and generates a task scheduling fragment.

[0006] S2: Based on the task scheduling segment, the gateway detects the heartbeat round-trip time, network card queue count, processor utilization, memory utilization, and task concurrency, determines the scheduling entry point, and generates a scheduling access list.

[0007] S3: Based on the scheduling admission list, the execution server collects the remaining number of times and the number of times the plugin is admitted, calls the number of task records, calculates the number of times according to the number of task records and the number of times the plugin is admitted, filters the plugin licenses, and generates a list of plugin licenses.

[0008] S4: Based on the plugin license list, the execution server calculates the batch based on the processor utilization rate, memory utilization rate, remaining plugin counts and admission counts, according to the difference between the upper limits of processor and memory utilization rates and the count quotient, and generates task batch instructions.

[0009] S5: Based on the task batch instruction, the gateway determines the task allocation according to the network priority, writes the task scheduling segment, target service interface address, plug-in service identifier and task batch instruction into the task allocation instruction, and generates an intelligent agent task collaborative control scheme.

[0010] As a further aspect of the present invention, the task scheduling segment includes round difference, interface segment, plugin segment, dependency level, and scheduling order; the scheduling admission list includes admission server, admission status, link latency level, resource load level, and concurrency capacity level; the plugin license list includes licensed object, license status, remaining license quota, single task license quota, and task usage quota; the task batch instruction includes batch size, batch number, execution wave, resource balance, and quota balance; and the intelligent agent task collaborative control scheme includes assignment object, interface pointer, plugin pointer, batch relationship, collaborative order, and gateway path.

[0011] As a further aspect of the present invention, the difference between the upper limit of memory utilization refers to the difference between the preset upper limit of memory utilization and the current memory utilization, which represents the remaining available memory space of the server.

[0012] As a further aspect of the present invention, the plug-in service identifier refers to the unique identifier of the target plug-in service, which verifies the specific plug-in service that the task depends on and calls.

[0013] The task batch instruction refers to the task batch execution control instruction generated based on the processor, memory resource availability, and plugin license count, to verify the batch scheduling and assignment method of tasks.

[0014] As a further aspect of the present invention, the specific steps of S1 are as follows:

[0015] S101: Obtain the user terminal task instruction, perform boundary positioning on the task round field, the preceding reference field, the business interface field and the plugin identifier field, extract the task round identifier, the preceding task reference mark, the target business interface address and the plugin service identifier, and establish an instruction field mapping table according to the round encoding caliber.

[0016] S102: Based on the instruction field mapping table, perform a difference operation on the task round identifier and the round identifier corresponding to the reference mark of the preceding task, and mark the round relationship according to three states: the difference is zero, the difference is positive, and the reference is empty, to obtain the round difference mark value;

[0017] S103: Based on the round gap marker value, map the target business interface address and plugin service identifier to three dependency categories: same-round dependency, cross-round dependency, and no preceding dependency. Arrange the interface address and plugin identifier according to the dependency category, aggregate the dependency category, interface address, plugin identifier, and round gap marker value, and generate a task scheduling segment.

[0018] As a further aspect of the present invention, the specific steps of S2 are as follows:

[0019] S201: Obtain the task scheduling segment, detect the heartbeat request sending timestamp and response receiving timestamp during the time when the intelligent agent execution server returns to the network service gateway via the network switching device, calculate the difference between the two timestamps and normalize it to the millisecond dimension, collect the server network card queuing number, processor utilization rate, memory utilization rate and task concurrency, and establish a running status feature table.

[0020] S202: Based on the running status feature table, compare the heartbeat round-trip delay with the admission delay benchmark value, the server network card queue number with the network card queue benchmark value, the processor utilization rate with the processor occupation benchmark value, the memory utilization rate with the memory occupation benchmark value, and the task concurrency with the concurrency capacity benchmark value to obtain the entry status judgment value.

[0021] S203: Based on the entry status judgment value, perform admission screening on the task scheduling segment. If none of the five comparison results exceed the corresponding benchmark value, it is marked as admitted. If any comparison result exceeds the corresponding benchmark value, it is marked as blocked. Associate the admission mark with the task scheduling segment to generate a scheduling admission list.

[0022] As a further aspect of the present invention, the specific steps of S3 are as follows:

[0023] S301: Based on the scheduling admission list, match the admission marker with the execution key value of the task scheduling segment, filter the admission marker as an admission list item, extract the plug-in service identifier in the task scheduling segment, collect the remaining number of plug-ins and the number of single-task plug-ins admitted by the intelligent agent execution server in the plug-in server, and establish a plug-in number parameter table.

[0024] S302: Call the plugin count parameter table, retrieve the item with the same name in the task scheduling segment according to the plugin service identifier, count the number of corresponding task records, and multiply the number of task records with the number of single task plugin access times in the dimension of times to obtain the plugin count usage value.

[0025] S303: Based on the plugin usage value, compare the plugin usage value with the remaining plugin usage value item by item. If the plugin usage value does not exceed the remaining plugin usage value, mark it as permitted. If the plugin usage value exceeds the remaining plugin usage value, mark it as rejected. Associate the permitted value with the plugin service identifier to generate a plugin permitted list.

[0026] As a further aspect of the present invention, the specific steps of S4 are as follows:

[0027] S401: Based on the plugin license list, perform key-value matching between the license marker and the plugin service identifier, filter the license marker as a license list item, call the intelligent agent execution server to calculate the corresponding processor usage, memory usage, plugin remaining times and single task plugin admission times, and establish a batch parameter mapping table.

[0028] S402: Call the batch parameter mapping table, perform a difference calculation between the processor utilization rate and the upper limit benchmark value of the processor utilization rate, perform a difference calculation between the memory utilization rate and the upper limit benchmark value of the memory utilization rate, and perform an integer quotient calculation between the remaining number of plug-ins and the number of times the single task plug-in is admitted, in units of the number of times, to obtain the batch capacity determination value.

[0029] S403: Based on the batch capacity determination value, perform a similar capacity comparison on the difference in processor utilization rate upper limit, the difference in memory utilization rate upper limit, and the integer quotient calculation result, select the value that has not exceeded the capacity boundary, associate the plug-in service identifier with the license list item, and generate the task batch instruction.

[0030] As a further aspect of the present invention, the specific steps of S5 are as follows:

[0031] S501: Based on the task batch instruction, call the plugin license list and task scheduling fragment, perform key-value matching on the license tag, plugin service identifier and the same-name identifier in the task scheduling fragment, retain the license tag as a license list item, extract the target business interface address and plugin service identifier, and establish a dispatch candidate mapping table.

[0032] S502: According to the dispatch candidate mapping table, obtain the network order of the agent execution server, match the network order with the batch number execution order in the task batch instruction, allocate the batch number in ascending order of network order, mark the items that cross the batch number boundary as pending dispatch, and obtain the task dispatch judgment value.

[0033] S503: Call the task assignment judgment value, associate the task scheduling segment marked as assigned in the project, the target business interface address, the plug-in service identifier and the task batch instruction as a task assignment instruction, arrange the task assignment instructions according to the network order of the agent execution server, and generate an agent task collaborative control scheme.

[0034] A network service-based intelligent agent task collaborative control system includes:

[0035] The task scheduling fragment generation module is used to implement S1: The user terminal obtains the task round identifier, the preceding task reference mark, the target business interface address and the plug-in service identifier, calculates the round difference, divides the target business interface address and plug-in service identifier dependency according to the round difference, and generates the task scheduling fragment.

[0036] The scheduling admission detection module is used to implement S2: Based on the task scheduling segment, the gateway detects the heartbeat round-trip latency, network card queue count, processor utilization, memory utilization, and task concurrency, determines the scheduling entry point, and generates a scheduling admission list;

[0037] The plugin license filtering module is used to implement S3: The execution server collects the remaining number of times and the number of times the plugin is admitted based on the scheduling admission list, calls the number of task records, calculates the number of times according to the number of task records and the number of times the plugin is admitted, filters the plugin licenses, and generates a plugin license list.

[0038] The task batch instruction generation module is used to implement S4: The execution server, based on the plugin license list, calls the processor utilization rate, memory utilization rate, remaining plugin times and admission times, calculates the batch based on the difference between the upper limits of processor and memory utilization rate and the quotient of the number of times, and generates task batch instructions;

[0039] The task coordination and assignment control module is used to implement S5: The gateway assigns tasks based on the task batch instructions according to the network order, writes the task scheduling segment, target service interface address, plug-in service identifier and task batch instructions into the task assignment instruction, and generates an intelligent agent task coordination control scheme.

[0040] Compared with the prior art, the advantages and positive effects of the present invention are as follows:

[0041] In this invention, a common-source scheduling segment is established using task round identifiers, preceding task reference markers, interface addresses, and service identifiers. Cross-round dependencies are first split and incorporated into the gateway admission judgment. Heartbeat round-trip latency, network card queuing count, processor utilization, memory utilization, and concurrency jointly limit the entry point. Permission filtering no longer stops at the role scope but transforms the remaining number of plugin attempts, admission attempts, and call record count into executable boundaries. Batch generation further absorbs the difference between processor and memory limits and the attempt quotient. Assignment instructions are written to tasks according to network order. Running status, permit reserves, dependencies, and batch size are closed in the same link, thereby reducing the risks of task backlog, resource conflicts, permit overdraft, and reassignment delays. Attached Figure Description

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

[0043] Figure 1 This is a schematic diagram of the steps of the present invention;

[0044] Figure 2 This is a detailed schematic diagram of S1 of the present invention;

[0045] Figure 3 This is a detailed schematic diagram of S2 of the present invention;

[0046] Figure 4 This is a detailed schematic diagram of S3 of the present invention;

[0047] Figure 5 This is a detailed schematic diagram of S4 of the present invention;

[0048] Figure 6 This is a detailed schematic diagram of S5 of the present invention. Detailed Implementation

[0049] The technical solution of the present invention will now be described with reference to the accompanying drawings.

[0050] To make the technical problems, technical solutions and advantages of the present invention clearer, a detailed description will be given below in conjunction with the accompanying drawings and specific embodiments.

[0051] Please see Figure 1 This invention provides a method for intelligent agent task collaborative control based on network services, comprising the following steps:

[0052] S1: Based on the user terminal task instructions, obtain the task round identifier, the preceding task reference mark, the target business interface address and the plug-in service identifier, calculate the difference between the task round identifier and the round identifier corresponding to the preceding task reference mark, and divide the target business interface address and plug-in service identifier according to the difference calculation results to generate task scheduling fragments.

[0053] S2: Based on task scheduling segments, detect the heartbeat round-trip time, server network card queue count, processor utilization, memory utilization, and task concurrency during the process of the intelligent agent execution server returning to the network service gateway via the network switching device. Based on the heartbeat round-trip time, server network card queue count, processor utilization, memory utilization, and task concurrency, determine the scheduling entry and generate a scheduling admission list.

[0054] S3: Based on the scheduling admission list, collect the remaining number of times the intelligent agent execution server registers the plugin on the plugin server and the number of times the single task plugin is admitted. Call the number of task records corresponding to the plugin service identifier in the task scheduling segment, calculate the number of times according to the number of task records and the number of times the single task plugin is admitted, and filter the plugin licenses based on the number of times calculation results to generate a plugin license list.

[0055] S4: Based on the list of licensed plugins, call the intelligent agent to execute the server to calculate the corresponding processor usage, memory usage, remaining plugin counts, and single-task plugin access counts. Perform batch calculations according to the difference between the upper limit of processor usage, the difference between the upper limit of memory usage, the quotient of the remaining plugin counts and the single-task plugin access counts, and generate task batch instructions.

[0056] S5: Based on the task batch instructions, call the plugin license list and task scheduling fragments, perform task assignment judgment according to the network order of the agent execution server and the task batch instructions, write the task scheduling fragments, target business interface addresses, plugin service identifiers and task batch instructions into the task assignment instructions, and generate an agent task collaborative control scheme.

[0057] The task scheduling segment includes round difference, interface segment, plugin segment, dependency level, and scheduling order. The scheduling admission list includes admission server, admission status, link latency level, resource load level, and concurrency capacity level. The plugin license list includes licensed object, license status, remaining license quota, single task license quota, and task usage quota. The task batch instructions include batch size, batch number, execution wave, resource balance, and quota balance. The intelligent agent task collaborative control scheme includes assignment object, interface pointer, plugin pointer, batch relationship, collaborative order, and gateway path.

[0058] Please see Figure 2 The specific steps of S1 are as follows:

[0059] S101: Obtain the user terminal task instruction, perform boundary positioning on the task round field, the preceding reference field, the business interface field and the plugin identifier field, extract the task round identifier, the preceding task reference mark, the target business interface address and the plugin service identifier, and establish an instruction field mapping table according to the round encoding caliber.

[0060] The system acquires Hypertext Markup Language (HMR) format message data transmitted by the user terminal via Transmission Control Protocol (TCP). It retrieves the payload start offset from the message header, traverses the payload content byte-order, matches the preset task round field start and end locators, and extracts the underlying string data between the two locators as the task round identifier. Simultaneously, it traverses the payload content, retrieves the key-value pair structure of the preceding reference field, and extracts the value corresponding to the key name as the preceding task reference marker. It locates the starting position of the Universal Resource Locator (URL) in the business interface field and extracts the string up to the newline character as the target business interface address. It scans the fixed-length hash feature sequence of the plugin identifier field and extracts this sequence as the plugin service identifier. A two-dimensional hash mapping structure is created through memory addressing operations, using the task round identifier as the primary key and the preceding task reference marker, target business interface address, and plugin service identifier as the corresponding values. Following the ascending order of the task round identifiers, the extracted data is written one by one to construct the instruction field mapping table. For example, when the obtained task round identifier is 5, the preceding task reference identifier is 3, the target business interface address is the order query interface address, and the plugin service identifier is the verification code recognition component identifier, 5 is used as the primary key, and the other 3 parameters are packaged and written into the corresponding hash slot.

[0061] S102: Based on the instruction field mapping table, perform a difference operation on the task round identifier and the corresponding round identifier of the previous task reference mark, and mark the round relationship according to three states: the difference is zero, the difference is positive, and the reference is empty, to obtain the round difference mark value;

[0062] Read each data record from the instruction field mapping table, extract the task round identifier value of the current record, and extract the preceding task reference mark value corresponding to the current record. Subtract the preceding task reference mark value from the task round identifier value, performing a difference operation. The first type of judgment condition is set to a difference operation result equal to 0; in this case, the round relationship of the current record is marked as same-round dependency. The second type of judgment condition is set to a difference operation result greater than 0; in this case, the round relationship of the current record is marked as cross-round dependency. The third type of judgment condition is set to a preceding task reference mark value that is null or a preset invalid placeholder; in this case, the difference operation is skipped, and the round relationship of the current record is directly marked as no preceding dependency. The label values ​​of the same-round dependency, cross-round dependency, or no preceding dependency states obtained above are assigned as round difference mark values ​​to the corresponding data records. For example, when the task round identifier value is 5 and the preceding task reference identifier value is 3, the result 2 is obtained through difference calculation. This result is greater than 0, triggering the second type of judgment condition, marking the record as a cross-round dependency state, and generating a round difference identifier value for cross-round dependency.

[0063] S103: Based on the round gap marker value, map the target business interface address and plugin service identifier to three dependency categories: same-round dependency, cross-round dependency, and no preceding dependency. Arrange the interface address and plugin identifier according to the dependency category, aggregate the dependency category, interface address, plugin identifier and round gap marker value, and generate a task scheduling fragment.

[0064] Read the data record carrying the round-difference marker value. Based on the round-difference marker value indicating same-round dependency, cross-round dependency, or no preceding dependency, initialize three independent data sets in memory. If the round-difference marker value indicates same-round dependency, write the target business interface address and plugin service identifier from the record into the first data set. If the round-difference marker value indicates cross-round dependency, write the target business interface address and plugin service identifier into the second data set. If the round-difference marker value indicates no preceding dependency, write the target business interface address and plugin service identifier into the third data set. Within each data set, sort in ascending order according to the lexicographical order of the target business interface addresses. When interface addresses are the same, sort in a secondary ascending order according to the lexicographical order of the plugin service identifiers. After sorting, read the contents of these three data sets and concatenate the dependency category label, the sorted target business interface address, the sorted plugin service identifier, and the initial round-difference marker value according to a preset fixed data structure to generate a task scheduling fragment with a fixed-length header.

[0065] Please see Figure 3 The specific steps of S2 are as follows:

[0066] S201: Obtain task scheduling segments, detect the heartbeat request sending timestamp and response receiving timestamp during the process of the intelligent agent execution server returning to the network service gateway via the network switching device, calculate the difference between the two timestamps and normalize it to the millisecond dimension, collect the server network card queuing number, processor utilization, memory utilization and task concurrency, and establish a running status feature table;

[0067] Parse the data structure of the task scheduling segment and extract the task distribution instructions. Send a network control protocol echo request message to the agent execution server and record the first timestamp parameter of the message sent from the network service gateway's network card. Capture the echo response message returned by the agent execution server on the socket listening port of the network service gateway and record the second timestamp parameter of the received message. Subtract the first timestamp parameter from the second timestamp parameter to obtain the absolute time span of the network transmission. Multiply this absolute time span by 1,000,000 and perform a unit conversion operation to obtain the heartbeat round-trip delay parameter in milliseconds. Log in to the agent execution server via the secure shell protocol, read the network interface statistics file in the system kernel pseudo-file system, and extract the number of backlogged data packets in the transmission queue as the server's network card queue count. Read the user-mode time, system-mode time, and idle time from the system status pseudo-file. Add the user-mode time and system-mode time, divide by the total time, and multiply the quotient by 100% to obtain the processor utilization rate. Read the available physical memory capacity and total physical memory capacity from the memory information file. Subtract the available physical memory capacity from the total physical memory capacity, divide the difference by the total physical memory capacity, and multiply the quotient by 100% to obtain the memory utilization rate. Execute the network status statistics command to filter the number of Transmission Control Protocol sockets in the connection establishment state, using this as the task concurrency. Combine the above five parameters to generate a runtime status characteristic table. The specific data structure is shown in Table 1.

[0068] Table 1 Operating Status Characteristics Table

[0069] Heartbeat round-trip delay 12 millisecond Port capture calculation Server network card queue number 45 indivual Network statistics files Processor utilization 65 % Status pseudo-file Memory usage 72 % Memory pseudo file Concurrency of tasks 1250 indivual Status statistics command

[0070] Table 1 lists the specific values ​​and sources of five key operational status parameters collected from the agent execution server.

[0071] S202: Based on the running status feature table, compare the heartbeat round-trip delay with the admission delay baseline, the number of server network card queues with the network card queue baseline, the processor utilization rate with the processor occupancy baseline, the memory utilization rate with the memory occupancy baseline, and the number of concurrent tasks with the concurrent capacity baseline to obtain the entry status judgment value.

[0072] Extract the values ​​from the runtime status feature table. Retrieve five baseline parameters pre-stored in the local configuration library, specifically: an admission latency baseline of 50 milliseconds, a network interface card (NIC) queue baseline of 100 packets, a processor utilization baseline of 80%, a memory utilization baseline of 85%, and a concurrent capacity baseline of 2000 connections. Compare the heartbeat round-trip latency with the admission latency baseline. Compare the server NIC queue count with the NIC queue baseline. Compare the processor utilization with the processor utilization baseline. Compare the memory utilization with the memory utilization baseline. Compare the task concurrency with the concurrent capacity baseline. Record the Boolean results of the above five comparison operations, and package these five Boolean results into a 5-bit entry status judgment value bit string. For example, when the heartbeat round-trip delay is 12 milliseconds and the admission delay baseline is 50 milliseconds, the comparison result is not exceeded, and the corresponding judgment value bit position is 0. If a parameter exceeds the baseline value, the corresponding bit position is set to 1.

[0073] S203: Based on the entry status judgment value, perform admission screening on the task scheduling segment. If none of the five comparison results exceed the corresponding benchmark value, it is marked as admitted. If any comparison result exceeds the corresponding benchmark value, it is marked as blocked. Associate the admission mark with the task scheduling segment to generate a scheduling admission list.

[0074] The entry state judgment bit string is traversed through 5 positions. The first-level logical verification rule is set as follows: all positions in the bit string have a value of 0, meaning the comparison results of the 5 parameters have not exceeded their respective baseline values. When the first-level logical verification rule is met, a character-type flag indicating admission is generated in the system cache. The second-level logical verification rule is set as follows: at least one position in the bit string has a value of 1, meaning any one of the 5 parameters has exceeded its corresponding baseline value. When the second-level logical verification rule is met, a character-type flag indicating blocking is generated in the system cache. The generated character-type flag is added to the appended field at the end of the task scheduling segment, establishing a physical memory mapping association between the character-type flag and the task scheduling segment. All task scheduling segments carrying admission character-type flags are aggregated and written to a separate read-only storage area to generate a scheduling admission list.

[0075] Please see Figure 4 The specific steps of S3 are as follows:

[0076] S301: Based on the scheduling admission list, match the admission marker with the execution key value of the task scheduling segment, filter the admission marker as an admission list item, extract the plug-in service identifier in the task scheduling segment, collect the remaining number of plug-ins and the number of single-task plug-ins admitted by the intelligent agent execution server in the plug-in server, and establish a plug-in number parameter table.

[0077] Read all data entries in the scheduling admission list and extract the character markers from the appended fields at the end of each entry. Perform key-value matching verification between the extracted character markers and the preset admission constant string. Remove data entries that fail to match, and retain the list items whose character markers are equivalent to the admission constant string. Parse the task scheduling segments in the retained list items, locate the interval where the plugin identifier field is located according to the preset field offset rules, copy the hash feature sequence within that interval, and complete the extraction of the plugin service identifier. Call the Hypertext Transfer Protocol to send a query request message to the agent execution server, carrying the extracted plugin service identifier in the message payload. Receive the Uniform Resource Locator (URL) response data returned by the agent execution server, parse the content of the remaining quantity field in the data body to extract the plugin remaining count parameter, and parse the content of the single quota field in the data body to extract the single task plugin admission count parameter. Write the above plugin service identifier, plugin remaining count parameter, and single task plugin admission count parameter into a single data table in a relational database to generate a plugin count parameter table.

[0078] S302: Call the plugin count parameter table, retrieve the item with the same name in the task scheduling segment by the plugin service identifier, count the number of corresponding task records, multiply the number of task records with the number of single task plugin access times in the dimension of times, and obtain the plugin count usage value.

[0079] The system sends a structured query to the relational database, retrieving data from the plugin count parameter table. It reads the currently processed plugin service identifier and performs a full string matching search in the global data stream of the corresponding task scheduling segment. For each string segment perfectly matching the plugin service identifier, the system's hit counter is incremented by 1. After completing the traversal search, the final value of the hit counter is read and defined as the corresponding task record count. The system then reads the single-task plugin admission count parameter from the plugin count parameter table and multiplies it with the corresponding task record count. For example, if the full string matching search yields 15 corresponding task records and the read single-task plugin admission count parameter is 20, multiplying 15 by 20 results in a value of 300. The result of this product is defined as the plugin count usage value.

[0080] S303: Based on the plugin usage count, compare the plugin usage count with the remaining plugin usage count item by item. If the plugin usage count does not exceed the remaining plugin usage count, mark it as permitted. If the plugin usage count exceeds the remaining plugin usage count, mark it as denied. Associate the permitted flag with the plugin service identifier to generate a plugin permitted list.

[0081] Read the calculated plugin usage count and retrieve the corresponding remaining plugin usage count parameter from the plugin usage count parameter table. Compare the plugin usage count and remaining plugin usage count parameter in a comparator to perform item-by-item difference evaluation. Set the permission decision condition to be that the plugin usage count is less than or equal to the remaining plugin usage count parameter. Set the rejection decision condition to be that the plugin usage count is greater than the remaining plugin usage count parameter. When the permission decision condition is triggered, generate a permitted enumeration type flag in the memory data dictionary. When the rejection decision condition is triggered, generate a rejected enumeration type flag. Bind the generated enumeration type flags to the corresponding plugin service identifiers using pointers and write them into a new linked list structure. Extract the node data of all nodes carrying permitted enumeration type flags from the linked list, merge these node data, and output them to generate a plugin license list. For example, if the plugin usage count is 300 obtained in the previous calculation, and the remaining plugin usage count is 10000 read from the parameter table, then 300 is compared with 10000. Since 300 does not exceed the boundary of 10000, the license determination condition is met, and a license tag will be generated and bound to the plugin service identifier.

[0082] Please see Figure 5 The specific steps of S4 are as follows:

[0083] S401: Based on the plugin license list, perform key-value matching between the license tag and the plugin service identifier, filter the license tag as a license list item, call the agent execution server to calculate the corresponding processor usage, memory usage, plugin remaining times and single task plugin admission times, and establish a batch parameter mapping table.

[0084] Read the linked list of plugin licenses and extract the enumeration type markers from the linked list nodes. Perform key-value matching between the extracted enumeration type markers and the preset license constant strings. Keep the linked list nodes with true matching results and classify them as license list items. For each license list item, read its bound plugin service identifier. Connect to the status monitoring port of the agent execution server via the internal remote procedure call protocol to retrieve the current processor utilization and memory utilization values ​​of the server. Synchronously access the plugin count parameter table in the relational database and extract the remaining plugin count parameter and single-task plugin admission count parameter corresponding to the plugin service identifier. Allocate a contiguous storage space in memory, starting with the plugin service identifier, and sequentially write the processor utilization, memory utilization, remaining plugin count, and single-task plugin admission count into the adjacent address space to construct a data dictionary composed of parameter address pointers and generate a batch parameter mapping table. See Table 2 for the specific structure.

[0085] Table 2 Batch Parameter Mapping Table

[0086] Text analysis components 40% 50% 10000 20 Image rendering component 55% 60% 5000 50

[0087] Table 2 lists two types of plug-in service identifiers and their corresponding runtime resource data and quota parameters in the batch parameter mapping table.

[0088] S402: Call the batch parameter mapping table, perform a difference calculation between the processor utilization rate and the upper limit benchmark value of the processor utilization rate, perform a difference calculation between the memory utilization rate and the upper limit benchmark value of the memory utilization rate, and perform an integer quotient calculation between the remaining number of plug-ins and the number of times the single task plug-in is admitted, and obtain the batch capacity determination value.

[0089] Extract data from the batch parameter mapping table, retrieve the processor utilization cap baseline value set in the local configuration file (strictly set to 90%), and retrieve the memory utilization cap baseline value (strictly set to 95%). Subtract the extracted processor utilization value from the processor utilization cap baseline value and perform a difference calculation. Subtract the extracted memory utilization value from the memory utilization cap baseline value and perform a difference calculation. Divide the remaining number of times the plugin is used by the single-task plugin admission number of times parameter, and perform a rounding down quotient calculation. Use the calculated quotient result as the initial batch quota. Introduce resource conversion logic, setting each 1% difference in processor utilization to correspond to 10 batch units, and each 1% difference in memory utilization to correspond to 10 batch units. Multiply the processor utilization difference result by 10 to obtain the processor-based batch constraint value. Multiply the memory utilization difference result by 10 to obtain the memory-based batch constraint value. The batch constraint values ​​based on the processor and memory are aggregated with the initial batch quota to generate a batch capacity decision value array containing these three values. For example, when the processor utilization is 40%, the memory utilization is 50%, the plugin has 10,000 remaining attempts, and the single-task admission attempts are 20: The processor utilization limit difference is 90% minus 40% = 50%, multiplied by 10 to get 500 batch units. The memory difference is 95% minus 50% = 45%, multiplied by 10 to get 450 batch units. The integer quotient operation is 10,000 divided by 20 to get 500 batch units. The generated decision value array contains the three values: 500, 450, and 500.

[0090] S403: Based on the batch capacity determination value, perform a similar capacity comparison on the difference between the upper limit of processor utilization, the difference between the upper limit of memory utilization, and the integer quotient calculation result, select the value that has not exceeded the capacity boundary, associate the plug-in service identifier with the license list item, and generate the task batch instruction;

[0091] Read each value from the batch capacity determination value array. Perform a capacity comparison operation, iterating through the processor-based batch constraint values, memory-based batch constraint values, and initial batch quota in the array, and extract the minimum value among these three values. Define this minimum value as the value that has not exceeded the capacity boundary, representing the bottleneck capacity under the current multiple resource constraints. Write the extracted value that has not exceeded the capacity boundary into a structure containing the plug-in service identifier and license list item, and bind it as a new capacity attribute field. After completing the attribute field binding, serialize the structure into a standard Extensible Markup Language (EXPLAIN) format message to generate task batch instructions. In the above example, the minimum value extraction is performed on 500, 450, and 500 in the array, and the value that has not exceeded the capacity boundary is 450. This value is bound to the corresponding license list item and encapsulated into a complete task batch instruction for subsequent scheduling.

[0092] Please see Figure 6 The specific steps of S5 are as follows:

[0093] S501: Based on the task batch instruction, call the plugin license list and task scheduling fragment, perform key-value matching on the license tag, plugin service identifier and the same name identifier in the task scheduling fragment, retain the license tag as a license list item, extract the target business interface address and plugin service identifier, and establish a dispatch candidate mapping table.

[0094] The system receives generated task batch instruction messages, parses the message data body, and extracts the included plug-in service identifier and capacity attribute fields. It reads the plug-in license list and the original task scheduling fragment from the system global bus. It reads the enumeration type flag and plug-in service identifier from the plug-in license list and searches for the same-name field in the field space of the task scheduling fragment. A hash table collision detection mechanism is used to perform key-value matching. Data rows without collisions are removed, and license list items carrying license enumeration type flags are retained. For each retained license list item, the target business interface address and plug-in service identifier encapsulated within it are extracted by a fixed byte displacement. A data table with a row list structure is created in the local cache, and the target business interface address and plug-in service identifier are filled into the cells corresponding to the column names. Simultaneously, their memory access addresses in the original fragment are associated to create a dispatch candidate mapping table.

[0095] S502: According to the assignment candidate mapping table, obtain the network order of the agent's execution server, match the network order with the batch number execution order in the task batch instruction, allocate the batch number in ascending order of network order, mark the items that cross the batch number boundary as pending assignment, and obtain the task assignment judgment value.

[0096] Read the data rows from the candidate assignment mapping table and call the dynamic routing protocol to obtain the link state advertisement information of each agent execution server in the local area network. Extract the routing hop count parameter and average round-trip time parameter from the link state advertisement information, and multiply the routing hop count parameter by the average round-trip time parameter to obtain the network cost value. Arrange each agent execution server in ascending order of network cost value and assign it a network priority number starting from 1. Read the batch quantity carried in the task batch instruction, which is the 450 batch units obtained in the previous example. Allocate batch quantities to each agent execution server in ascending order of network priority, setting each server to allocate a fixed 200 batches at a time. Calculate the difference between the current allocation quantity and the remaining batch quantity. If the remaining batch quantity is greater than or equal to 200, allocate the full amount and move to the next priority. If the remaining batch quantity is less than 200, allocate all the remaining batches. Extract the sum of all allocation quantities and compare it with the total batch quantity. Remaining batches that cannot be allocated due to exceeding the receiving limit of the corresponding agent execution server are marked as pending assignment. The number of successfully assigned batches and their corresponding server network priority are recorded as task assignment judgment values. See Table 3 for details.

[0097] Table 3 Task Assignment Judgment Table

[0098] Node 1 1 200 200 250 Node 2 2 200 400 50 Node 3 3 50 450 0

[0099] Table 3 shows the data calculation process for distributing 450 batches of units sequentially according to network order.

[0100] S503: Call the task assignment judgment value, associate the task scheduling segment marked as assigned in the project, the target business interface address, the plug-in service identifier and the task batch instruction with the task assignment instruction, arrange the task assignment instructions according to the network order of the agent execution server, and generate an agent task collaborative control scheme.

[0101] Read the recorded task assignment judgment value data, extract the records of successfully assigned batches, and change their network status attribute to "assigned project". For each assigned project, call the memory access address in the assignment candidate mapping table to extract the corresponding task scheduling fragment, target business interface address, and plugin service identifier. Concatenate the above information with the corresponding task batch instructions into a complete executable script file to generate task assignment instructions. According to the previously determined network priority value of the agent execution server, arrange all generated task assignment instructions into a task queue with first-in-first-out characteristics. Publish the entire task queue to the distributed coordination service system to complete the final generation of the agent task collaborative control scheme.

[0102] A network service-based intelligent agent task collaborative control system includes:

[0103] The task scheduling fragment generation module is used to implement S1: The user terminal obtains the task round identifier, the preceding task reference mark, the target business interface address and the plug-in service identifier, calculates the round difference, divides the target business interface address and plug-in service identifier dependency according to the round difference, and generates the task scheduling fragment.

[0104] The scheduling admission detection module is used to implement S2: the gateway detects heartbeat round-trip latency, network card queue count, processor utilization, memory utilization and task concurrency based on task scheduling segments, determines the scheduling entry point, and generates a scheduling admission list;

[0105] The plugin license filtering module is used to implement S3: The execution server collects the remaining number of times and the number of times the plugin is admitted based on the scheduling admission list, calls the number of task records, calculates the number of times based on the number of task records and the number of times the plugin is admitted, filters the plugin licenses, and generates a plugin license list.

[0106] The task batch instruction generation module is used to implement S4: The execution server calculates batch instructions based on the plugin license list, processor utilization, memory utilization, remaining plugin times and admission times, and the difference between the upper limit of processor and memory utilization and the number of times, and generates task batch instructions.

[0107] The task coordination and dispatch control module is used to implement S5: The gateway dispatches tasks based on task batch instructions and network priority, and writes the task scheduling segment, target service interface address, plug-in service identifier and task batch instructions into the task dispatch instruction to generate an intelligent agent task coordination control scheme.

[0108] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of protection of the technical solution.

Claims

1. A method for collaborative control of intelligent agent tasks based on network services, characterized in that, Includes the following steps: S1: The user terminal obtains the task round identifier, the preceding task reference marker, the target business interface address and the plug-in service identifier, calculates the round difference, divides the target business interface address and plug-in service identifier dependency according to the round difference, and generates a task scheduling fragment. S2: Based on the task scheduling segment, the gateway detects the heartbeat round-trip time, network card queue count, processor utilization, memory utilization, and task concurrency, determines the scheduling entry point, and generates a scheduling access list. S3: Based on the scheduling admission list, the execution server collects the remaining number of times and the number of times the plugin is admitted, calls the number of task records, calculates the number of times according to the number of task records and the number of times the plugin is admitted, filters the plugin licenses, and generates a list of plugin licenses. S4: Based on the plugin license list, the execution server calculates the batch based on the processor utilization rate, memory utilization rate, remaining plugin counts and admission counts, according to the difference between the upper limits of processor and memory utilization rates and the count quotient, and generates task batch instructions. S5: Based on the task batch instruction, the gateway determines the task allocation according to the network priority, writes the task scheduling segment, target service interface address, plug-in service identifier and task batch instruction into the task allocation instruction, and generates an intelligent agent task collaborative control scheme.

2. The intelligent agent task cooperative control method based on network services according to claim 1, characterized in that, The task scheduling segment includes round difference, interface segment, plugin segment, dependency level, and scheduling order. The scheduling admission list includes admission server, admission status, link latency level, resource load level, and concurrency capacity level. The plugin license list includes licensed object, license status, remaining license quota, single task license quota, and task usage quota. The task batch instruction includes batch size, batch number, execution wave, resource balance, and quota balance. The intelligent agent task collaborative control scheme includes assignment object, interface pointer, plugin pointer, batch relationship, collaborative order, and gateway path.

3. The intelligent agent task cooperative control method based on network services according to claim 1, characterized in that, The difference between the upper limit of memory utilization refers to the difference between the preset upper limit of memory utilization and the current memory utilization, which represents the remaining available memory space of the server.

4. The intelligent agent task cooperative control method based on network services according to claim 1, characterized in that, The plugin service identifier refers to the unique identifier of the target plugin service, which verifies the specific plugin service that the task depends on and calls. The task batch instruction refers to the task batch execution control instruction generated based on the processor, memory resource availability, and plugin license count, to verify the batch scheduling and assignment method of tasks.

5. The intelligent agent task cooperative control method based on network services according to claim 1, characterized in that, The specific steps of S1 are as follows: S101: Obtain the user terminal task instruction, perform boundary positioning on the task round field, the preceding reference field, the business interface field and the plugin identifier field, extract the task round identifier, the preceding task reference mark, the target business interface address and the plugin service identifier, and establish an instruction field mapping table according to the round encoding caliber. S102: Based on the instruction field mapping table, perform a difference operation on the task round identifier and the round identifier corresponding to the reference mark of the preceding task, and mark the round relationship according to three states: the difference is zero, the difference is positive, and the reference is empty, to obtain the round difference mark value; S103: Based on the round gap marker value, map the target business interface address and plugin service identifier to three dependency categories: same-round dependency, cross-round dependency, and no preceding dependency. Arrange the interface address and plugin identifier according to the dependency category, aggregate the dependency category, interface address, plugin identifier, and round gap marker value, and generate a task scheduling segment.

6. The intelligent agent task cooperative control method based on network services according to claim 1, characterized in that, The specific steps of S2 are as follows: S201: Obtain the task scheduling segment, detect the heartbeat request sending timestamp and response receiving timestamp during the time when the intelligent agent execution server returns to the network service gateway via the network switching device, calculate the difference between the two timestamps and normalize it to the millisecond dimension, collect the server network card queuing number, processor utilization rate, memory utilization rate and task concurrency, and establish a running status feature table. S202: Based on the running status feature table, compare the heartbeat round-trip delay with the admission delay benchmark value, the server network card queue number with the network card queue benchmark value, the processor utilization rate with the processor occupation benchmark value, the memory utilization rate with the memory occupation benchmark value, and the task concurrency with the concurrency capacity benchmark value to obtain the entry status judgment value. S203: Based on the entry status judgment value, perform admission screening on the task scheduling segment. If none of the five comparison results exceed the corresponding benchmark value, it is marked as admitted. If any comparison result exceeds the corresponding benchmark value, it is marked as blocked. Associate the admission mark with the task scheduling segment to generate a scheduling admission list.

7. The intelligent agent task cooperative control method based on network services according to claim 1, characterized in that, The specific steps for S3 are as follows: S301: Based on the scheduling admission list, match the admission marker with the execution key value of the task scheduling segment, filter the admission marker as an admission list item, extract the plug-in service identifier in the task scheduling segment, collect the remaining number of plug-ins and the number of single-task plug-ins admitted by the intelligent agent execution server in the plug-in server, and establish a plug-in number parameter table. S302: Call the plugin count parameter table, retrieve the item with the same name in the task scheduling segment according to the plugin service identifier, count the number of corresponding task records, and multiply the number of task records with the number of single task plugin access times in the dimension of times to obtain the plugin count usage value. S303: Based on the plugin usage value, compare the plugin usage value with the remaining plugin usage value item by item. If the plugin usage value does not exceed the remaining plugin usage value, mark it as permitted. If the plugin usage value exceeds the remaining plugin usage value, mark it as rejected. Associate the permitted value with the plugin service identifier to generate a plugin permitted list.

8. The intelligent agent task cooperative control method based on network services according to claim 1, characterized in that, The specific steps of S4 are as follows: S401: Based on the plugin license list, perform key-value matching between the license marker and the plugin service identifier, filter the license marker as a license list item, call the intelligent agent execution server to calculate the corresponding processor usage, memory usage, plugin remaining times and single task plugin admission times, and establish a batch parameter mapping table. S402: Call the batch parameter mapping table, perform a difference calculation between the processor utilization rate and the upper limit benchmark value of the processor utilization rate, perform a difference calculation between the memory utilization rate and the upper limit benchmark value of the memory utilization rate, and perform an integer quotient calculation between the remaining number of plug-ins and the number of times the single task plug-in is admitted, in units of the number of times, to obtain the batch capacity determination value. S403: Based on the batch capacity determination value, perform a similar capacity comparison on the difference in processor utilization rate upper limit, the difference in memory utilization rate upper limit, and the integer quotient calculation result, select the value that has not exceeded the capacity boundary, associate the plug-in service identifier with the license list item, and generate the task batch instruction.

9. The intelligent agent task cooperative control method based on network services according to claim 1, characterized in that, The specific steps of S5 are as follows: S501: Based on the task batch instruction, call the plugin license list and task scheduling fragment, perform key-value matching on the license tag, plugin service identifier and the same-name identifier in the task scheduling fragment, retain the license tag as a license list item, extract the target business interface address and plugin service identifier, and establish a dispatch candidate mapping table. S502: According to the dispatch candidate mapping table, obtain the network order of the agent execution server, match the network order with the batch number execution order in the task batch instruction, allocate the batch number in ascending order of network order, mark the items that cross the batch number boundary as pending dispatch, and obtain the task dispatch judgment value. S503: Call the task assignment judgment value, associate the task scheduling segment marked as assigned in the project, the target business interface address, the plug-in service identifier and the task batch instruction as a task assignment instruction, arrange the task assignment instructions according to the network order of the agent execution server, and generate an agent task collaborative control scheme.

10. A network service-based intelligent agent task collaborative control system, characterized in that, The system is used to implement the network service-based intelligent agent task collaborative control method according to any one of claims 1-9, comprising: The task scheduling fragment generation module is used to implement S1: the user terminal obtains the task round identifier, the preceding task reference marker, the target business interface address, and the plugin service identifier. Calculate the round gap, divide the target business interface address and plugin service identifier dependency according to the round gap, and generate task scheduling fragments; The scheduling admission detection module is used to implement S2: Based on the task scheduling segment, the gateway detects the heartbeat round-trip latency, network card queue count, processor utilization, memory utilization, and task concurrency, determines the scheduling entry point, and generates a scheduling admission list; The plugin license filtering module is used to implement S3: The execution server collects the remaining number of times and the number of times the plugin is admitted based on the scheduling admission list, calls the number of task records, calculates the number of times according to the number of task records and the number of times the plugin is admitted, filters the plugin licenses, and generates a plugin license list. The task batch instruction generation module is used to implement S4: The execution server, based on the plugin license list, calls the processor utilization rate, memory utilization rate, remaining plugin times and admission times, calculates the batch based on the difference between the upper limits of processor and memory utilization rate and the quotient of the number of times, and generates task batch instructions; The task coordination and assignment control module is used to implement S5: The gateway assigns tasks based on the task batch instructions according to the network order, writes the task scheduling segment, target service interface address, plug-in service identifier and task batch instructions into the task assignment instruction, and generates an intelligent agent task coordination control scheme.

Images