Message transmission method and device

Abstract

The invention provides a message transmission method and equipment, which can be applied to the technical field of communication. The message transmission method comprises the following steps: an entry edge node obtains a message set; obtaining subtasks based on the message division strategy and the message set; and processing the message included in the message set based on the message processing strategy corresponding to the subtask. Wherein the message set comprises one or more messages. According to the message transmission method provided by the invention, fine-grained division, statistics, measurement or transmission processing can be carried out on the network transmission task, so that the utilization rate of network resources is improved, and the network performance is optimized.

Description

Technical Field

[0001] The present application relates to the field of communication technology, and in particular to a message transmission method and device. Background Art

[0002] In a wide area network, some services (such as artificial intelligence (AI) services and machine learning (ML) services) continuously occupy network resources but do not always use them and do not allow other services to use them, which may lead to low utilization of network resources.

[0003] Low network resource utilization leads to insufficient bandwidth utilization, meaning more bandwidth is idle and unavailable for packet transmission, resulting in reduced network throughput. Low network resource utilization also increases packet transmission latency, increasing network latency. Low network resource utilization also leads to insufficient utilization of available bandwidth, causing traffic congestion and, consequently, packet loss, retransmissions, and increased latency.

[0004] Therefore, how to improve the utilization of network resources and optimize network performance is an urgent problem that needs to be solved. Summary of the Invention

[0005] The present application provides a message transmission method and device that can improve the utilization of network resources and optimize network performance. For example, it can perform fine-grained division, statistics, measurement, or transmission processing on network transmission tasks (e.g., message flows), thereby improving the utilization of network resources and optimizing network performance.

[0006] In a first aspect, the present application provides a message transmission method, the method comprising:

[0007] The ingress edge node obtains a message set; based on the message partitioning strategy and the message set, obtains a subtask; and processes the messages included in the message set based on the message processing strategy corresponding to the subtask. The message set includes one or more messages.

[0008] In this solution, the ingress edge node first divides the received message set into different subtasks and then processes the messages in different subtasks (such as performing one or more of statistics, measurement, transmission, and scheduling on the messages in different subtasks). Furthermore, this solution can allocate network resources based on subtask processing granularity. Compared to allocating network resources based on service granularity, processing and allocating network resources based on subtask granularity is a finer granularity, which enables flexible configuration of network resources, thereby improving network resource utilization and optimizing network performance.

[0009] For example, existing solutions allocate routing paths based on service granularity. Because message flows within a service span long time spans, the allocated routing paths can occupy the allocated routing paths for extended periods of time. For bursty message flows, the routing paths are only used to transmit messages when a burst arrives, resulting in a shorter time spent transmitting messages. For example, routing paths R1 and R2 are allocated to transmit messages from message flow S (e.g., messages S1, S2, S3, etc.). Message flow S transmits a message set every 10 seconds, and the transmission time for this message set is less than the 10-second interval, for example, within 1 second. During this time, routing paths R1 and R2 are idle, preventing the transmission of other message flows. This results in low utilization of routing paths R1 and R2. In contrast, this solution derives fine-grained subtasks based on message sets and then allocates routing paths based on subtask granularity. Consequently, each subtask occupies one or more routing paths. Furthermore, after a subtask's message is transmitted, the routing path occupied by that subtask can be used by another subtask, thereby improving routing path utilization. Therefore, allocating routing paths based on subtask granularity can achieve load balancing and avoid wasting network resources caused by overloading a single routing path. At the same time, all available routing paths can be fully utilized to improve bandwidth utilization. This can also increase transmission speed and network throughput. If a routing path is congested or fails, messages from other subtasks can be transmitted via other routing paths, avoiding single points of failure and reducing network latency.

[0010] In some possible implementations, the message segmentation strategy includes at least one of an interval duration, a byte threshold, and a timeout duration.

[0011] In one specific implementation method, the above-mentioned message division strategy includes an interval duration, the above-mentioned message set includes a first message and a second message, and the above-mentioned entry edge node obtains a subtask based on the message division strategy and the message set, including: the entry edge node obtains the time of receiving the first message and the time of receiving the second message; based on the interval duration, the time of receiving the first message and the time of receiving the second message, determines that the first message belongs to the above-mentioned subtask, or determines that the first message and the second message belong to the above-mentioned subtask.

[0012] In this solution, the subtask corresponding to the first message and the subtask corresponding to the second message are determined based on the interval length, the time of receiving the first message and the time of receiving the second message. The size and transmission time of each subtask can be adjusted according to the specific application scenario and network resources, so that the subtask can better adapt to different network environments and transmission requirements, and the continuity of the messages in the subtask can be guaranteed.

[0013] In another specific implementation, the above-mentioned message segmentation strategy includes a byte threshold, the above-mentioned message set includes a first message and a second message, and the above-mentioned entry edge node obtains the subtask based on the message segmentation strategy and the message set, including: the entry edge node obtains the number of bytes of the first message and the number of bytes of the second message; based on the node threshold, the number of bytes of the first message and the number of bytes of the second message, determines that the first message belongs to the above-mentioned subtask, or determines that the first message and the second message belong to the above-mentioned subtask.

[0014] In this solution, the subtasks corresponding to the first and second messages are determined based on the byte threshold, the byte count of the first and second messages. This allows the size of each subtask to be controlled, allowing the subtasks to better adapt to different network environments and transmission requirements. If the subtask size is too large, it may lead to low message transmission efficiency; if the subtask size is too small, it may result in excessive message transmission overhead. On the other hand, the continuity of the messages within the subtask can be guaranteed.

[0015] In another specific implementation method, the above-mentioned message division strategy includes a timeout period, the above-mentioned message set includes a first message and a second message, and the above-mentioned entry edge node obtains the subtask based on the message division strategy and the message set, including: the entry edge node obtains the time of receiving the first message and the time of receiving the second message; based on the timeout period, the time of receiving the first message and the time of receiving the second message, determines that the first message belongs to the above-mentioned subtask, or determines that the first message and the second message belong to the above-mentioned subtask.

[0016] In this solution, the subtask corresponding to the first and second messages is determined based on the timeout duration, the time when the first message was received, and the time when the second message was received. This allows the message set to be divided into subtasks by leveraging its temporal characteristics, i.e., its bursty characteristics. This not only ensures the continuity of messages within the subtasks, but also provides a foundation for subsequent processing and allocation of network resources based on subtask granularity.

[0017] In some possible implementations, the message processing strategy includes at least one of statistics, measurement, and transmission.

[0018] In one specific implementation method, the above-mentioned message processing strategy includes statistics, and the above-mentioned entry edge node processes the messages included in the message set based on the message processing strategy corresponding to the subtask, including: the entry edge node performs statistics on the messages included in the message set corresponding to the subtask, and reports the statistical results.

[0019] In this solution, the packets in the subtasks are counted and statistical results are obtained. The statistical results can be used to understand the current network resource utilization and network performance. Furthermore, network resources can be redeployed based on the statistical results to improve network resource utilization and optimize network performance.

[0020] In another specific implementation method, the above-mentioned message processing strategy includes measurement, and the above-mentioned entry edge node processes the messages included in the message set based on the message processing strategy corresponding to the subtask, including: the entry edge node adds a measurement identifier to the message included in the message set corresponding to the subtask, and performs performance measurement based on the measurement identifier.

[0021] In this solution, measurement tags are added to the messages in the subtasks and performance measurements are performed based on the tags, resulting in performance measurement results that reflect network performance. Furthermore, network resources can be redeployed based on the performance measurement results to improve network resource utilization and optimize network performance.

[0022] In another specific implementation method, the above-mentioned message processing strategy includes transmission, and the above-mentioned entry edge node processes the messages included in the message set based on the message processing strategy corresponding to the subtask, including: the entry edge node forwards the messages included in the message set based on the priority corresponding to the subtask.

[0023] In this solution, messages within a message set are forwarded based on their corresponding subtask priorities. This allows for more network resources to be allocated to higher-priority subtasks and fewer to lower-priority ones. This ensures faster transmission of messages belonging to higher-priority subtasks, improving network responsiveness and real-time performance. This also prevents a single subtask from occupying too many network resources and hindering the transmission of other subtasks, thereby improving network resource utilization.

[0024] Furthermore, subtask priorities can be dynamically adjusted based on actual network needs. In situations of network congestion or high load, the priority of critical subtasks can be increased to ensure timely transmission of their messages. In situations of network idleness or low load, the priority of non-critical subtasks can be lowered to better utilize bandwidth resources.

[0025] In some possible implementations, the above method further includes:

[0026] The ingress edge node executes the step of obtaining the subtask based on the instruction sent by the egress edge node.

[0027] In this solution, the ingress edge node can execute the step of obtaining the subtask based on the instruction sent by the egress edge node. After obtaining the subtask, the ingress edge node can process the message in the subtask based on the message processing strategy corresponding to the subtask.

[0028] In some possible implementations, the above method further includes:

[0029] The ingress edge node sends a first message to the egress edge node, and receives a second message sent by the egress edge node. The first message is used to instruct the start of performance measurement or the sending of performance measurement results. The second message includes the performance measurement results.

[0030] In this solution, the egress edge node can trigger the performance measurement of the subtask according to the first message from the ingress edge node, without triggering the performance measurement of the subtask according to the received message.

[0031] In a second aspect, the present application provides a message transmission device comprising: an acquisition unit, a partitioning unit, and a processing unit. The acquisition unit is configured to acquire a message set. The partitioning unit is configured to acquire subtasks based on a message partitioning strategy and the message set. The processing unit is configured to process messages included in the message set based on message processing strategies corresponding to the subtasks. The message set includes one or more messages.

[0032] In some possible implementations, the message segmentation strategy includes at least one of an interval duration, a byte threshold, and a timeout duration.

[0033] In one specific implementation, the message partitioning strategy includes an interval duration, and the message set includes a first message and a second message. The partitioning unit is specifically configured to obtain a time when the first message is received and a time when the second message is received; and based on the interval duration, the time when the first message is received, and the time when the second message is received, determine whether the first message belongs to the subtask, or determine whether the first message and the second message belong to the subtask.

[0034] In another specific implementation, the message segmentation strategy includes a byte threshold, the message set includes a first message and a second message, and the segmentation unit is specifically configured to obtain a byte count of the first message and a byte count of the second message; and based on the byte threshold, the byte count of the first message, and the byte count of the second message, determine whether the first message belongs to the subtask, or determine whether the first message and the second message belong to the subtask.

[0035] In another specific implementation, the message partitioning strategy includes a timeout period, the message set includes a first message and a second message, and the partitioning unit is specifically configured to obtain a time when the first message is received and a time when the second message is received; and based on the timeout period, the time when the first message is received, and the time when the second message is received, determine whether the first message belongs to the subtask, or determine whether the first message and the second message belong to the subtask.

[0036] In some possible implementations, the message processing strategy includes at least one of statistics, measurement, and transmission.

[0037] In one specific implementation, the message processing strategy includes statistics, and the processing unit is specifically configured to collect statistics on the messages included in the message set corresponding to the subtask and report the statistical results.

[0038] In another specific implementation, the message processing strategy includes measurement. The processing unit is specifically configured to add a measurement identifier to the message included in the message set corresponding to the subtask, and perform performance measurement based on the measurement identifier.

[0039] In another specific implementation, the message processing strategy includes transmission. The processing unit is specifically configured to forward the messages included in the message set based on the priorities corresponding to the subtasks.

[0040] In some possible implementations, the device further includes an execution unit configured to execute the step of acquiring the subtask based on an instruction sent by the egress edge node.

[0041] In some possible implementations, the device further includes a sending unit and a receiving unit. The sending unit is configured to send a first message to an egress edge node. The first message is configured to instruct the start of performance measurement or the transmission of a performance measurement result. The receiving unit is configured to receive a second message sent by the egress edge node. The second message includes the performance measurement result.

[0042] In a third aspect, the present application provides a message transmission device, comprising a processor and a memory, wherein the memory is used to store instructions, and the processor is used to execute the instructions. When the processor executes the instructions, it implements the method in the first aspect or any possible implementation of the first aspect.

[0043] In a fourth aspect, the present application provides a computer-readable storage medium comprising computer program instructions. When the computer program instructions are executed by a computing device, the computing device executes the method in the first aspect or any possible implementation of the first aspect.

[0044] In a fifth aspect, the present application provides a computer program product comprising instructions, which, when executed by a computing device, causes the computing device to execute the method in the first aspect or any possible implementation of the first aspect. BRIEF DESCRIPTION OF THE DRAWINGS

[0045] Figure 1A This is a structural diagram of a message transmission system provided by an embodiment of the present application;

[0046] Figure 1B This is a structural diagram of another message transmission system provided in an embodiment of the present application;

[0047] Figure 2 This is a flow chart of a message transmission method provided in an embodiment of the present application;

[0048] Figure 3 This is a schematic diagram of a target message set provided by an embodiment of the present application;

[0049] Figure 4A This is a flow chart of a performance measurement process provided by an embodiment of the present application;

[0050] Figure 4B This is a schematic diagram of another performance measurement process provided by an embodiment of the present application;

[0051] Figure 4C This is a schematic diagram of another performance measurement process provided by an embodiment of the present application;

[0052] Figure 4D This is a schematic diagram of another performance measurement process provided by an embodiment of the present application;

[0053] Figure 4E This is a schematic diagram of another performance measurement process provided by an embodiment of the present application;

[0054] Figure 4F This is a schematic diagram of another performance measurement process provided by an embodiment of the present application;

[0055] Figure 4G This is a schematic diagram of another performance measurement process provided by an embodiment of the present application;

[0056] Figure 4H This is a flow chart of a scheduling message provided in an embodiment of the present application;

[0057] Figure 5 This is a possible logical structure diagram of the message transmission device provided in the embodiment of the present application;

[0058] Figure 6 This is a possible hardware structure diagram of the message transmission device provided in an embodiment of the present application. DETAILED DESCRIPTION

[0059] The embodiments of the present application are described below in conjunction with the drawings in the embodiments of the present application.

[0060] Before introducing the embodiments of the present application, the concepts and relationships between services and message flows are briefly introduced.

[0061] The business is used to implement a specific service. The business may include, for example, AI business, ML business, or audio and video business, etc., which is not limited in the embodiment of this application.

[0062] A message stream is a series of messages transmitted over a network to complete a specific service. For example, an IP message stream consists of a series of messages with the same source and destination addresses, protocol numbers (Transmission Control Protocol (TCP) or User Datagram Protocol (UDP)), source and destination port numbers. Alternatively, a message stream for a specific service can consist of messages with the same source and destination addresses but different protocol numbers, source and destination ports.

[0063] One or more message streams can be transmitted within the same service. For example, in a machine learning service, users can purchase cloud services on a cloud platform and use it to train machine learning models online. Users send training data to multiple servers on the cloud platform (such as server D1 and server D2) through a terminal node. These servers then use the training data to collaboratively train the machine learning model. Specifically, the terminal node encapsulates the training data into two message streams, message stream S1 and message stream S2, and sends message stream S1 to server D1 and message stream S2 to server D2. Server D1 obtains training data from message stream S1, trains the machine learning model using the training data, obtains the first optimization parameters of the machine learning model, and encapsulates the first optimization parameters into message stream S3 and sends them to server D2. Server D2 obtains training data from message stream S2, trains the machine learning model using the training data, obtains the second optimization parameters of the machine learning model, aggregates the first and second optimization parameters to obtain the global optimization parameters, and uses the global optimization parameters to update the machine learning model. Server D2 also encapsulates the global optimization parameters into message stream S4 and sends it to server D1. Server D1 obtains the global optimization parameters from message stream S4 and uses the global optimization parameters to update the ML model.

[0064] It should be noted that the above ML service is only an example and not a specific limitation.

[0065] In the process of improving network resource utilization and optimizing network performance to better complete network transmission tasks, it is found that when using high-bandwidth network resources to perform network transmission tasks, network resources are often used in bursts. If this bursty network resource usage pattern can be effectively handled and scheduled, network resource utilization can be significantly improved and network performance can be optimized.

[0066] The above-mentioned bursty use of network resources is closely related to the bursty reception of messages by network nodes. The following will take the entry edge node for receiving messages from terminal nodes as an example of a network node to specifically introduce the scenario of bursty reception of messages by network nodes. Figure 2 The introduction of the target message set received by the ingress edge node in step S201 includes: Figure 3 And its related contents, as well as, (1) obtaining the target message set based on the application scenario of the target message set; (2) obtaining the target message set based on the routing path; (3) obtaining the target message set based on the user identifier.

[0067] For the above-mentioned mode of effectively processing and scheduling the bursty use of network resources, please refer to the message transmission method provided in the following embodiment of the present application, for details, see Figure 2 And an introduction to related content.

[0068] In the embodiment of the present application, two message transmission systems will be used as examples to introduce the message transmission method provided by the embodiment of the present application. The first message transmission system and the second message transmission system can both be used to generate messages and transmit messages. Among them, the first message transmission system can be referred to Figure 1A And the introduction of related content. The second message transmission system can be found in Figure 1B And an introduction to related content.

[0069] (1) The first message transmission system

[0070] See also Figure 1A , Figure 1A This is a schematic diagram of the structure of a message transmission system provided by an embodiment of the present application. Figure 1A As shown, the message transmission system 10 includes terminal nodes and network nodes, wherein communication can be performed between terminal nodes, between terminal nodes and network nodes, and between network nodes.

[0071] exist Figure 1AIn the example, terminal nodes are used to generate messages and include U11 to U16 and U21 to U26. Terminal nodes include one or more of personal computers, workstations, enterprise sites, mobile devices (such as mobile phones), IoT devices (such as sensors, cameras, smart home devices, smart wearable devices, and smart vehicles), and embedded devices (such as embedded systems, industrial control equipment, and automation equipment).

[0072] exist Figure 1A In the example, network nodes are used to transmit messages, including L11 to L17. The network nodes include one or more of switches, routers, load balancers, and optical fiber communication equipment (such as optical fiber switches and optical fiber splitters).

[0073] exist Figure 1A In the present invention, terminal nodes and network nodes can communicate with each other via wired or wireless means. Wired means include one or more of Ethernet, TCP / IP, Open Shortest Path First (OSPF), Border Gateway Protocol (BGP), etc. Wireless means include one or more of Wireless Local Area Network (WLAN) and Bluetooth, etc.

[0074] It should be noted that the communication method between terminal nodes and the communication method between network nodes are similar to the communication method between terminal nodes and network nodes mentioned above. For the sake of brevity of the specification, they will not be elaborated here.

[0075] In the embodiment of the present application, according to the transmission direction of the message, the network node includes an ingress edge node and an egress edge node, wherein the ingress edge node is used to receive messages from the terminal node, and the egress edge node is used to send messages to the terminal node.

[0076] For example, in Figure 1A In FIG, when a message is transmitted from the terminal node on the left to the terminal node on the right in the message transmission system 10, the ingress edge nodes include L11, L12, and L13, and the egress edge nodes include L16 and L17.

[0077] The correspondence between the ingress edge node and the terminal node is specifically as follows: L11 is used to receive messages from U11 or U12; L12 is used to receive messages from U13 or U14; and L13 is used to receive messages from U15 or U16.

[0078] The correspondence between the egress edge node and the terminal node is specifically as follows: L16 is used to send messages to one or more of U21, U22, and U23; L17 is used to send messages to one or more of U24, U25, and U26.

[0079] It should be noted that the first message transmission system mentioned above is based on Figure 1A The message transmission system 10 includes 12 terminal nodes and 7 network nodes for illustration. In actual applications, the number of terminal nodes and network nodes can be one or more, and this application does not make specific limitations.

[0080] (2) The second message transmission system

[0081] See also Figure 1B , Figure 1B This is a structural diagram of another message transmission system provided by an embodiment of the present application. Figure 1B As shown, the message transmission system 20 includes terminal nodes, network nodes and a network management server (NMS). Among them, terminal nodes can communicate with each other, with network nodes, with network nodes, and with the NMS.

[0082] exist Figure 1B In the example, the terminal nodes are used to generate messages, including U31~U36 and U41~U46. The terminal nodes can be Figure 1A The terminal nodes in .

[0083] exist Figure 1B In the example, network nodes are used to transmit messages, including L21 to L27, as well as SP1 and SP2. The network nodes can be Figure 1A The network nodes in .

[0084] exist Figure 1B In the network, NMS is used to obtain information about network nodes and use the information to comprehensively monitor, manage and optimize network nodes to ensure the stability, security and high-performance operation of message transmission.

[0085] exist Figure 1B In the communication mode between terminal nodes, between terminal nodes and network nodes, between network nodes and network nodes, and between network nodes and NMS, Figure 1A The communication method between the terminal node and the network node is similar, and for the sake of brevity of the description, it will not be elaborated here.

[0086] In some possible implementations, the message transmission system 20 employs a leaf-spine topology. Therefore, the network nodes in the message transmission system 20 can be divided into leaf switches and spine switches. Leaf switches communicate with spine switches and forward received messages to spine switches. Spine switches communicate with leaf switches and perform message forwarding and routing between leaf switches.

[0087] In message transmission system 20, because each leaf switch is directly connected to each spine switch, multiple parallel paths are implemented, providing greater bandwidth capacity and lower transmission latency. Furthermore, because each leaf switch is directly connected only to each spine switch and not to other leaf switches, the number of links in message transmission system 20 is reduced, simplifying the network structure of message transmission system 20.

[0088] For example, in Figure 1B In the example, leaf switches include L21 to L27, and spine switches include SP1 and SP2.

[0089] The relationship between leaf switches, spine switches, and end nodes is as follows: L21 forwards packets from U31 or U32 to SP1 or SP2; L22 forwards packets from U33 or U34 to SP1 or SP2; L23 forwards packets from U35 or U36 to SP1 or SP2; L26 forwards packets from U41, U42, or U43 to SP1 or SP2; and L27 forwards packets from U44, U45, or U46 to SP1 or SP2. SP1 or SP2 forwards packets from one of the leaf switches L21-L27 to another leaf switch.

[0090] In the embodiment of the present application, according to the transmission direction of the message, the leaf switch includes an ingress edge node and an egress edge node, wherein the ingress edge node is used to receive messages from the terminal node, and the egress edge node is used to send messages to the terminal node.

[0091] For example, in Figure 1B In the example, when a message is transmitted from the terminal node on the left to the terminal node on the right in the message transmission system 20, the ingress edge nodes include L21, L22, and L23, and the egress edge nodes include L26 and L27.

[0092] The correspondence between the entry edge node and the terminal node is specifically as follows: L21 is used to receive messages from U21 or U22; L22 is used to receive messages from U23 or U24; L23 is used to receive messages from U25 or U26.

[0093] The correspondence between the egress edge node and the terminal node is specifically as follows: L26 is used to send messages to one or more of U41, U42 and U43; L27 is used to send messages to one or more of U44, U45 and U46.

[0094] It should be noted that the second message transmission system mentioned above is based on Figure 1B The message transmission system 10 includes 12 terminal nodes, 7 leaf switches, 2 spine switches and 1 NMS for illustration. In actual applications, the number of terminal nodes, leaf switches, spine switches and NMS can be one or more, and this application does not make specific limitations.

[0095] It should be noted that the application scenarios of the message transmission method provided in the embodiments of the present application are not limited to the above-mentioned (1) first message transmission system and (2) second message transmission system. The scenarios in which the message transmission method provided in the embodiments of the present application can be applied are all within the scope of protection of this application.

[0096] The following describes a message processing method provided in an embodiment of the present application, which can be applied to any of the above-mentioned message transmission systems.

[0097] See also Figure 2 , Figure 2 This is a flow chart of a message transmission method provided by an embodiment of the present application. Figure 2 As shown, the method may include but is not limited to the following steps:

[0098] S201: The terminal node sends a target message set to the ingress edge node, wherein the target message set includes one or more messages.

[0099] Accordingly, the ingress edge node receives the target message set from the terminal node.

[0100] Among them, the above terminal node can be Figure 1A One or more of U11~U16 and U21~U26. The ingress edge node can be Figure 1A The corresponding relationship between the ingress edge node and the terminal node can refer to the corresponding relationship between the ingress edge node and the terminal node in the first message transmission system (I) above.

[0101] Alternatively, the above terminal node can be Figure 1B One or more of U31~U36 and U41~U46. The entry edge node can be Figure 1BThe corresponding relationship between the ingress edge node and the terminal node can refer to the corresponding relationship between the ingress edge node and the terminal node in the second message transmission system (II) above.

[0102] In some possible application scenarios, the target message set received by the ingress edge node has a burst characteristic. For example, the target message set is the ML service message set between terminal nodes U11 and U21. The ML service may take 1 week to complete, but the target message set is bursty and transmits messages of about 1 second at a high speed every 10 seconds or so. Therefore, the ingress edge node always receives batch messages continuously for a period of time, then takes a period of time, and then receives batch messages continuously for a period of time. Alternatively, after the ingress edge node receives batch messages continuously for a period of time, it no longer receives new messages. In an embodiment of the present application, the message set formed by batch messages can be referred to as a message set. Therefore, the target message set received by the ingress edge node may include one or more message sets. A message set includes one or more messages. When the target message set includes multiple message sets, there is a time interval between any two adjacent message sets in the multiple message sets.

[0103] Below is Figure 1A L11 in FIG. 1 is used as an example of an ingress edge node to specifically introduce the burst characteristics of the target packet set.

[0104] See also Figure 3 , Figure 3 This is a schematic diagram of a target message set provided by an embodiment of the present application. Figure 3 As shown, the target message set received by L11 includes message set M1, message set M2 and message set M3.

[0105] exist Figure 3 In the example, the reception status of each message set is as follows: L11 receives the first message of message set M1 at 20 seconds; and receives the last message of message set M1 at 20.5 seconds. Therefore, the time it takes L11 to receive message set M1 is 0.5 seconds. L11 receives the first message of message set M2 at 30 seconds; and receives the last message of message set M2 at 32 seconds. Therefore, the time it takes L11 to receive message set M2 is 2 seconds. L11 receives the first message of message set M3 at 40 seconds; and receives the last message of message set M3 at 41.1 seconds. Therefore, the time it takes L11 to receive message set M3 is 1.1 seconds.

[0106] exist Figure 3In the example, the time interval between two adjacent message sets is as follows: the time interval between the last message of message set M1 and the first message of message set M2 is 9.5 seconds; the time interval between the last message of message set M2 and the first message of message set M3 is 8 seconds.

[0107] from Figure 3 It can be seen that after receiving packet set M1, L11 waited 9.5 seconds before receiving packet set M2, and then waited another 8 seconds before receiving packet set M3. Furthermore, the time interval between two adjacent packet sets is much longer than the reception time of each packet set. Therefore, the target packet set received by L11 exhibits burst characteristics.

[0108] It should be noted that the above L11 receiving the target message set with burst characteristics is only an example and does not limit the target message set received by L11 to have the burst characteristics. In some possible application scenarios, the target message sets received by other network nodes also have the burst characteristics.

[0109] In some possible implementations, the ingress edge node acquires a target message set with burst characteristics based on one or more of a network address, a routing path, and a user identifier. The network address is used to indicate a terminal node or network node, and includes an IP address and / or port number, etc. The routing path is used to indicate the transmission path of a message in a message transmission system. The user identifier is used to indicate a user, and includes a five-tuple (source IP address, destination IP address, protocol type, source port number, destination port number), a three-tuple (source IP address, destination IP address, identifier), a numerical value, a letter, a symbol, or any combination thereof.

[0110] Among them, the application scenario of the ingress edge node obtaining the target message set with burst characteristics can refer to the following (1) application scenario of obtaining the target message set, including: (1) obtaining the target message set based on the network address; (2) obtaining the target message set based on the routing path; (3) obtaining the target message set based on the user identifier.

[0111] In another possible implementation, the target packet set received by the ingress edge node may not have obvious burst characteristics. For example, the target packet set may be a series of packets of a video service.

[0112] S202: The ingress edge node obtains subtasks based on the message partitioning strategy and the target message set.

[0113] The ingress edge node receives the target message set and processes the target message set, which may include statistics, measurement, transmission, scheduling, etc. For the convenience of subsequent description, the embodiment of the present application refers to the processing of the target message set by the ingress edge node as a target task.

[0114] In some possible implementations, a message partitioning strategy is used to partition the target message set in step S201 above to obtain subtasks. Specifically, the message partitioning strategy can divide the target message set into one or more sub-message sets, each of which corresponds to a subtask. That is, each subtask is used to process (for example, including statistics, measurement, transmission, and scheduling) messages in the corresponding sub-message set. A sub-message set can be a message set. A message set can be a sub-message set of another message set. Furthermore, the message set can include multiple sub-message sets.

[0115] In some possible implementations, the message segmentation strategy may include one or more of an interval duration, a byte threshold, a timeout duration, and a message identifier. Specifically, the target message set may be segmented based on one or more of the interval duration, the byte threshold, the timeout duration, and the message identifier to obtain the subtasks.

[0116] The interval duration is a time length having a first value, which is used to determine the time point for dividing the subtasks. The first value is determined by the user, such as 1 hour, 1 day, or 1 week. The specific implementation method of dividing the above target message set according to the interval duration to obtain the above subtasks can refer to (1) Obtaining subtasks based on interval duration in the following (2) Implementation method of obtaining subtasks.

[0117] The byte threshold is a number of bytes having a second value, and is used to determine the total length of the messages included in the subtask. The second value is determined by the user, such as 3Kbytes, 3Gbytes, or 30Gbytes. The target message set is divided according to the byte threshold to obtain a specific implementation of the subtask. For details, see (2) Acquiring a Subtask Based on a Byte Threshold in the following (II) Implementation of Acquiring a Subtask.

[0118] The timeout duration is a time length having a third value. The timeout duration is used to indicate that the above-mentioned entry edge node has not received the next message after receiving a message and the timeout duration has passed. The third value is determined by the user, such as 5 seconds, 5 minutes, or 5 hours. The above-mentioned target message set is divided according to the timeout duration to obtain the specific implementation method of the above-mentioned subtask. Please refer to (3) in the following (2) implementation method of obtaining the subtask to obtain the subtask based on the timeout duration.

[0119] The message identifier is used to determine the identifier of the message included in the subtask. The message identifier can be represented by a number, a letter, a symbol, or any combination thereof. In a specific implementation, the message identifier can be the user identifier in step S201 above. The above target message set is divided according to the message identifier to obtain the specific implementation of the above subtask. For the implementation of (2) obtaining the subtask, refer to (4) obtaining the subtask based on the message identifier in the following (2) obtaining the subtask implementation.

[0120] S203: The ingress edge node processes the messages included in the target message set based on the message processing strategy corresponding to the subtask.

[0121] In some possible implementations, the message processing policy is used to indicate how to process the message, including one or more of statistics, measurement, transmission, and scheduling.

[0122] Statistics are used to obtain the transmission status of packets, for example, one or more of the number of packets, number of bytes, start time, and end time.

[0123] The measurement is used to obtain network performance of transmitted packets, for example, one or more of packet loss rate and packet transmission delay.

[0124] The transmission is used to determine the priority of the message, for example, one or more of low priority, normal priority, high priority, and emergency priority, etc.

[0125] Scheduling is used to control the routing path of a message, for example, one or more of forwarding, pausing forwarding, and not forwarding.

[0126] In some possible implementations, a subtask may correspond to one or more message processing policies. When a subtask corresponds to one message processing policy, the ingress edge node performs only one type of processing on the messages in the subtask, such as statistics, measurement, transmission, or scheduling. When a subtask corresponds to multiple message processing policies, the ingress edge node performs multiple types of processing on the messages in the subtask, such as statistics and transmission.

[0127] In some possible implementations, the ingress edge node processes the messages included in the target message set (i.e., the messages included in the subtask) based on the message processing strategy corresponding to the subtask. The processing method of the messages in the subtask can refer to the following (3) processing method of the messages in the subtask, including: (1) messages in the statistics subtask; (2) messages in the measurement subtask; (3) messages in the transmission subtask; and (4) messages in the scheduling subtask.

[0128] To summarize, the ingress edge node first divides the received target message set into different subtasks based on one or more of the interval duration, byte threshold, timeout duration, and message identifier in the message division strategy, and then processes the messages in different subtasks (such as performing one or more of statistics, measurement, transmission, and scheduling on the messages in different subtasks). Furthermore, this solution can allocate network resources based on the processing of subtask granularity. Compared with allocating network resources based on the processing of service granularity, the processing and allocation of network resources based on the subtask granularity is a finer granularity, which can achieve flexible configuration of network resources, thereby improving the utilization of network resources and optimizing network performance.

[0129] It should be noted that the above is executed by the entry edge node Figure 2 Step S202 and step S203 are just an example. In actual applications, other network nodes (such as egress edge nodes) or terminal nodes may also perform the steps. Figure 2 Step S202 and step S203 in the embodiment are not specifically limited here.

[0130] The following is the above Figure 2 The application scenario in which the entry edge node obtains the target message set in step S201 is specifically introduced.

[0131] (1) Application scenarios for obtaining target message sets

[0132] Application scenarios in which an ingress edge node obtains a target message set with burst characteristics include: (1) obtaining a target message set based on a network address; (2) obtaining a target message set based on a routing path; and (3) obtaining a target message set based on a user identifier.

[0133] (1) Obtaining the target message set based on the network address

[0134] In some possible application scenarios, the ingress edge node obtains a target packet set with burst characteristics based on the network address. For details, please refer to the following application scenarios 1 and 2:

[0135] Application scenario 1: All packets in the target packet set carry the same source IP address and destination IP address, and carry the same source port number and destination port number. The burst characteristics of the target packet set are the time domain characteristics reflected by the same packet flow between the same pair of terminal nodes transmitted to the ingress edge node.

[0136] After receiving a packet set from the source port number of the terminal node with the source IP address, the ingress edge node receives another packet set from the same source port after a certain period of time. Therefore, the target packet set obtained by the ingress edge node has a burst characteristic.

[0137] Application scenario 2: All packets in the target packet set carry the same source IP address and destination IP address, but different source port numbers or destination port numbers. The burst characteristics of the target packet set are the time domain characteristics reflected by different packet flows between the same pair of terminal nodes transmitted to the ingress edge node.

[0138] The ingress edge node receives different sets of packets from different source port numbers of a terminal node with a source IP address, with a certain interval between receiving the two packet sets. Alternatively, the ingress edge node receives packets with different destination port numbers from the same source port number of a terminal node with a source IP address, with a certain interval between receiving the two packet sets. Therefore, the target packet sets received by the ingress edge node exhibit burst characteristics.

[0139] Let's continue with the above Figure 3 As an example, application scenario 1 and application scenario 2 of (1) obtaining a target message set based on a network address are specifically introduced.

[0140] In application scenario 1 of (1) obtaining the target message set based on the network address, it is assumed that the messages of message set M1, message set M2 and message set M3 all carry source IP address = U11, destination IP address = U21, source port number = X1 and destination port number = Y1.

[0141] In the aforementioned Figure 1A In this example, U11 sends a message set to L11, which then forwards it to U21. Specifically, U11's X1 first sends message set M1 to L11. After a while, U11's X1 sends message set M2 to L11. After another delay, U11's X1 sends message set M3 to L11. L11 then forwards message sets M1, M2, and M3 to U21's Y1.

[0142] Combined with the above Figure 3 At 20 seconds, L11 receives the first message of message set M1 from U11's X1. 9.5 seconds after receiving the last message of message set M1, L11 receives the first message of message set M2 from U11's X1. 8 seconds after receiving the last message of message set M2, L11 receives the first message of message set M3 from U11's X1. At 41.1 seconds, L11 receives the last message of message set M3.

[0143] In application scenario 2 of (1) obtaining a target message set based on a network address, assume that messages in message set M1 carry source IP address = U11, destination IP address = U21, source port number = X1, and destination port number = Y1. Messages in message set M2 carry source IP address = U11, destination IP address = U21, source port number = X2, and destination port number = Y1. Messages in message set M3 carry source IP address = U11, destination IP address = U21, source port number = X1, and destination port number = Y2.

[0144] In the aforementioned Figure 1A In the example, U11 sends a message set to L11, which then forwards it to U21. Specifically, U11's X1 sends message set M1 to L11. After a while, U11's X2 sends message set M2 to L11. After another delay, U11's X1 sends message set M3 to L11. L11 forwards message sets M1 and M2 to U21's Y1 and M3 to U21's Y2.

[0145] Combined with the above Figure 3 At 20 seconds, L11 receives the first message of message set M1 from U11's X1. 9.5 seconds after receiving the last message of message set M1, L11 receives the first message of message set M2 from U11's X2. 8 seconds after receiving the last message of message set M2, L11 receives the first message of message set M3 from U11's X1. At 41.1 seconds, L11 receives the last message of message set M3.

[0146] (2) Obtaining the target message set based on the routing path

[0147] In some possible application scenarios, the ingress edge node obtains a target packet set with burst characteristics based on the routing path. For details, please refer to the following application scenarios 1 and 2:

[0148] Application scenario 1: All message sets in the target message set come from the same terminal node and are forwarded by the same ingress edge node. The burst characteristics of the target message set are the time domain characteristics reflected by one or more message flows between the same terminal node and network node transmitted to the ingress edge node.

[0149] After receiving a packet set from a terminal node, the ingress edge node receives another packet set from the same terminal node after a certain period of time. Therefore, the target packet set obtained by the ingress edge node has a burst characteristic.

[0150] Application scenario 2: The message sets in the target message set come from different terminal nodes but are all forwarded by the same ingress edge node. The burst characteristics of the target message set are the time domain characteristics reflected by the transmission of multiple message flows between different terminal nodes and network nodes to the ingress edge node.

[0151] After receiving a packet set from a terminal node, the ingress edge node receives another packet set from another terminal node after a certain period of time. Therefore, the target packet set obtained by the ingress edge node has a burst characteristic.

[0152] Let's continue with the above Figure 3 As an example, application scenario 1 and application scenario 2 of (2) obtaining a target message set based on a routing path are specifically introduced.

[0153] In application scenario 1 of (2) obtaining a target message set based on a routing path, it is assumed that message set M1, message set M2, and message set M3 all come from U11.

[0154] In the aforementioned Figure 1A In the example, U11 sends message sets M1, M2, and M3 to L11. L11 forwards these messages. Specifically, U11 first sends message set M1 to L11. After a while, U11 sends message set M2 to L11. After another while, U11 sends message set M3 to L11.

[0155] Combined with the above Figure 3 At 20 seconds, L11 receives the first message of message set M1 from U11. 9.5 seconds after receiving the last message of message set M1, L11 receives the first message of message set M2 from U11. 8 seconds after receiving the last message of message set M2, L11 receives the first message of message set M3 from U11. At 41.1 seconds, L11 receives the last message of message set M3.

[0156] In application scenario 2 of (2) obtaining a target message set based on a routing path, it is assumed that message set M1 and message set M3 come from U11, and message set M2 comes from U12.

[0157] In the aforementioned Figure 1A In this example, U11 sends message sets M1 and M3 to L11. U12 sends message set M2 to L11. L11 forwards message sets M1, M2, and M3. Specifically, U11 first sends message set M1 to L11. After a period of time, U12 sends message set M2 to L11. After another period of time, U11 sends message set M3 to L11.

[0158] Combined with the above Figure 3 At 20 seconds, L11 receives the first message of message set M1 from U11. 9.5 seconds after receiving the last message of message set M1, L11 receives the first message of message set M2 from U12. 8 seconds after receiving the last message of message set M2, L11 receives the first message of message set M3 from U11. At 41.1 seconds, L11 receives the last message of message set M3.

[0159] (3) Obtaining the target message set based on the user ID

[0160] In some possible application scenarios, the ingress edge node obtains a target packet set with burst characteristics based on the user identifier. For details, please refer to the following application scenarios 1 and 2:

[0161] Application scenario 1: All packets in the target packet set carry the same user ID. The burst feature of the target packet set is the time domain feature reflected by the packet flow carrying the same user ID being transmitted to the ingress edge node.

[0162] The ingress edge node receives multiple message sets carrying the same user identifier, and there is a certain interval between receiving two message sets. Therefore, the target message set obtained by the ingress edge node has a burst characteristic.

[0163] Application scenario 2: The message sets in the target message set carry different user identifiers. The burst characteristics of the target message set are the time domain characteristics reflected by the message flows carrying different user identifiers transmitted to the ingress edge node.

[0164] The ingress edge node receives multiple message sets carrying different user identifiers, and there is a certain interval between receiving two message sets. Therefore, the target message set obtained by the ingress edge node has a burst characteristic.

[0165] Let's continue with the above Figure 3 As an example, application scenario 1 and application scenario 2 of (3) obtaining a target message set based on a user identifier are specifically introduced.

[0166] In application scenario 1 of (3) obtaining a target message set based on a user identifier, it is assumed that message sets M1, M2, and M3 all carry user identifier A1. Message sets M1, M2, and M3 can come from the same terminal node or from different terminal nodes. The following description uses the example of message sets M1, M2, and M3 coming from the same terminal node.

[0167] In the aforementioned Figure 1AIn the example, assume that U11 sends message set M1, message set M2, and message set M3, each carrying user identifier A1, to L11. Specifically, U11 first sends message set M1, which carries user identifier A1, to L11. After a period of time, U11 sends message set M2, which also carries user identifier A1, to L11. After another period of time, U11 sends message set M3, which also carries user identifier A1, to L11.

[0168] Combined with the above Figure 3 At 20 seconds, L11 receives the first message of message set M1 carrying user identifier A1. 9.5 seconds after receiving the last message of message set M1 carrying user identifier A1, L11 receives the first message of message set M2 carrying user identifier A1. 8 seconds after receiving the last message of message set M2 carrying user identifier A1, L11 receives the first message of message set M3 carrying user identifier A1. At 41.1 seconds, L11 receives the last message of message set M3 carrying user identifier A1.

[0169] In application scenario 2 of (3) obtaining a target message set based on a user identifier, it is assumed that message sets M1 and M3 carry user identifier A1, and message set M2 carries user identifier A2. Message sets M1, M2, and M3 can come from the same terminal node or from different terminal nodes. The following description uses the example of message sets M1, M2, and M3 coming from the same terminal node.

[0170] In the aforementioned Figure 1A In the example, assume that U11 sends message set M1 and message set M3 carrying user identifier A1, as well as message set M2 carrying user identifier A2, to L11. Specifically, U11 first sends message set M1 carrying user identifier A1 to L11. After a period of time, U11 sends message set M2 carrying user identifier A2 to L11. After another period of time, U11 sends message set M3 carrying user identifier A1 to L11.

[0171] Combined with the above Figure 3 At 20 seconds, L11 receives the first message of message set M1 carrying user identifier A1. 9.5 seconds after receiving the last message of message set M1 carrying user identifier A1, L11 receives the first message of message set M2 carrying user identifier A2. 8 seconds after receiving the last message of message set M2 carrying user identifier A2, L11 receives the first message of message set M3 carrying user identifier A1. At 41.1 seconds, L11 receives the last message of message set M3 carrying user identifier A1.

[0172] It should be noted that the above-mentioned sending of message set M1, message set M2 and message set M3 by the same terminal node to the entry edge node is only an example. Message set M1, message set M2 and message set M3 can also be sent to the entry edge node by different terminal nodes, which is not specifically limited here.

[0173] It should be noted that the above (1) obtaining the target message set based on the network address - (3) obtaining the target message set based on the user identifier is only an example. The entry edge node can also obtain the target message set with burst characteristics based on at least two of the network address, routing path and user identifier. For example, the entry edge node obtains the target message set based on the network address and user identifier, which is not specifically limited here.

[0174] It should be noted that the above-mentioned ingress edge node obtaining the target message set is only an example. In actual applications, other network nodes (such as egress edge nodes) or terminal nodes can also obtain the target message set with burst characteristics, including (1) obtaining the target message set based on the network address - (3) obtaining the target message set based on the user identifier, which is not specifically limited here.

[0175] The following is the above Figure 2 The implementation method of the ingress edge node obtaining the subtask from the target message set based on the message partitioning strategy in step S202 is specifically introduced.

[0176] (2) How to obtain subtasks

[0177] The following takes the first message and the second message in the target message set as an example to determine the subtask corresponding to the first message and the subtask corresponding to the second message as an example of obtaining subtasks from the target message set, and introduces the implementation method of obtaining subtasks from the target message set based on the message partitioning strategy, including: (1) obtaining subtasks based on interval duration; (2) obtaining subtasks based on byte threshold; (3) obtaining subtasks based on timeout duration; (4) obtaining subtasks based on message identifier.

[0178] The first message and the second message may belong to the same message set or different message sets, and the second message is received by the ingress edge node after receiving the first message.

[0179] (1) Obtain subtasks based on interval duration

[0180] In some possible implementations, the entry edge node determines the subtask corresponding to the first message and the subtask corresponding to the second message based on the interval duration, the time when the first message is received, and the time when the second message is received. Wherein, the interval duration is the time interval between the k+1th time point and the kth time point, k∈N +, the k+1th time point is later than the kth time point. For the specific implementation method, please refer to the following implementation method 1:

[0181] Implementation method 1: Compare ① the kth time point, ② the k+1th time point, ③ the time when the first message is received, and ④ the time when the second message is received.

[0182] Specifically, the entry edge node sets the first time point, takes the time point represented by the sum of the first time point and the interval duration as the second time point, and takes the time point represented by the sum of the second time point and the interval duration as the third time point...thus obtaining ① the kth time point and ② the k+1th time point.

[0183] The ingress edge node obtains ③ the time of receiving the first message and ④ the time of receiving the second message, and determines whether ③ the time of receiving the first message and ④ the time of receiving the second message are between ① the kth time point and ② the k+1th time point.

[0184] As an example, assuming the interval is 8 hours and the first time point is 23:00 every day, the time point 7:00 represented by the sum of 23:00 and 8 hours is used as the second time point, and the time point 15:00 represented by the sum of 7:00 and 8 hours is used as the third time point.

[0185] As another example, assuming the interval is 10 hours, the first time point is when the entry edge node starts working, the second time point is when the entry edge node has been working for 10 hours, and the third time point is when the entry edge node has been working for 30 hours.

[0186] It should be noted that the above interval is 8 hours or 10 hours, and the first time point is 23:00 every day or the time point when the entry edge node starts working. This is only an example and is not specifically limited here.

[0187] In the implementation method 1 of (1) obtaining subtasks based on the interval duration, based on the relationship between ①, ②, ③ and ④, the subtask corresponding to the first message and the subtask corresponding to the second message mainly include the following two situations:

[0188] Case 1: ③ is later than or equal to ①, ③ is earlier than ②, and ④ is later than or equal to ②. The ingress edge node determines that the first message and the second message belong to different subtasks.

[0189] Case 2: ③ and ④ are both later than or equal to ①, and ③ and ④ are both earlier than ②. The ingress edge node determines that the first message and the second message belong to the same subtask.

[0190] Therefore, the subtask includes the message corresponding to the above Figure 2Case 1 to Case 5 in the message included in the subtask in step S202.

[0191] It should be noted that the above-mentioned implementation method 1 (1) of obtaining a subtask based on the interval duration is merely an example and is not specifically limited here. In actual applications, any implementation method that can determine the subtask corresponding to the first message and the subtask corresponding to the second message based on the interval duration, the time when the first message is received, and the time when the second message is received is within the scope of protection of this application.

[0192] To sum up, based on the interval length, the time of receiving the first message and the time of receiving the second message, the subtask corresponding to the first message and the subtask corresponding to the second message are determined. The size and transmission time of each subtask can be adjusted according to the specific application scenario and network resources, so that the subtask can better adapt to different network environments and transmission requirements, and the continuity of the messages in the subtask can be guaranteed.

[0193] (2) Obtaining subtasks based on byte thresholds

[0194] In some possible implementations, the ingress edge node determines the subtask corresponding to the first message and the subtask corresponding to the second message based on the byte threshold, the number of bytes in the first message, and the number of bytes in the second message. For specific implementations, please refer to the following implementation 1:

[0195] Implementation method 1: Compare ① the sum of the total number of bytes of the messages in the subtask to which the first message belongs and the number of bytes of the second message, and ② the byte threshold. The total number of bytes of the messages in the subtask to which the first message belongs includes the number of bytes of the first message.

[0196] Specifically, the ingress edge node obtains the byte count of each message (including the first message) in the subtask to which the first message belongs, adds the byte count of each message (including the first message) to obtain the total byte count. The ingress edge node obtains the byte count of the second message, adds the byte count of the second message to the total byte count, and determines whether the sum of the byte count of the second message and the total byte count is greater than the byte threshold.

[0197] In the implementation method 1 of (2) obtaining the subtask based on the byte threshold, based on the relationship between ① and ②, the subtask corresponding to the first message and the subtask corresponding to the second message mainly include the following two situations:

[0198] Case 1: ① is greater than ②, and the ingress edge node determines that the first message and the second message belong to different subtasks.

[0199] Case 2: ① is less than or equal to ②, and the ingress edge node determines that the first message and the second message belong to the same subtask.

[0200] Therefore, the subtask includes the message corresponding to the above Figure 2 Case 1 to Case 5 in the message included in the subtask in step S202.

[0201] It should be noted that the above-mentioned implementation method 1 of (2) obtaining a subtask based on a byte threshold is merely an example and is not specifically limited here. In actual applications, any implementation method that can determine the subtask corresponding to the first message and the subtask corresponding to the second message based on the byte threshold, the number of bytes in the first message, and the number of bytes in the second message is within the scope of protection of this application.

[0202] In summary, determining the subtask corresponding to the first and second messages based on the byte threshold, the byte count of the first and second messages allows for control over the size of each subtask, enabling it to better adapt to different network environments and transmission requirements. If the subtask size is too large, it may result in low message transmission efficiency; if the subtask size is too small, it may result in excessive message transmission overhead. On the other hand, this also ensures the continuity of messages within the subtask.

[0203] (3) Get subtasks based on timeout duration

[0204] In some possible implementations, the ingress edge node determines the subtask corresponding to the first message and the subtask corresponding to the second message based on the timeout duration, the time when the first message was received, and the time when the second message was received. The second message is the next message received by the ingress edge node after receiving the first message. Therefore, the time when the second message is received is later than the time when the first message is received. For specific implementations, please refer to Implementation 1 and Implementation 2 below:

[0205] Implementation method 1: Compare ① the time when the second message is received, and ② the time represented by the sum of the time when the first message is received and the timeout duration.

[0206] Specifically, the ingress edge node receives the first message, obtains the time when the first message is received, and determines whether the second message is received within a timeout period from the time when the first message is received.

[0207] In the implementation method 1 of (3) obtaining the subtask based on the timeout duration, based on the relationship between ① and ②, the subtask corresponding to the first message and the subtask corresponding to the second message mainly include the following two situations:

[0208] Case 1: ① is later than ②, indicating that after the ingress edge node receives the first message, it does not receive the second message within the timeout period. Therefore, the ingress edge node determines that the first message and the second message belong to different subtasks.

[0209] Case 2: ① is earlier than ②, indicating that the ingress edge node receives the second message within the timeout period after receiving the first message. Therefore, the ingress edge node determines that the first message and the second message belong to the same subtask.

[0210] Therefore, the subtask includes the message corresponding to the above Figure 2 Case 1 in the message included in the subtask in step S202.

[0211] Implementation method 2: Compare ① the time difference between the time when the second message is received and the time when the first message is received, and ② the timeout duration.

[0212] Specifically, the ingress edge node receives a first message and obtains a time at which the first message is received. The ingress edge node receives a second message and obtains a time at which the second message is received. The ingress edge node determines a time difference between the time at which the second message is received and the time at which the first message is received, and determines whether the time difference is greater than a timeout period.

[0213] In the implementation method 2 of (3) obtaining the subtask based on the timeout duration, based on the relationship between ① and ②, the subtask corresponding to the first message and the subtask corresponding to the second message mainly include the following two situations:

[0214] Case 1: ① is greater than ②, indicating that after the ingress edge node receives the first message, it does not receive the second message within the timeout period. Therefore, the ingress edge node determines that the first message and the second message belong to different subtasks.

[0215] Case 2: ① is less than or equal to ②, indicating that after the ingress edge node receives the first message, it receives the second message within the timeout period. Therefore, the ingress edge node determines that the first message and the second message belong to the same subtask.

[0216] Therefore, the subtask includes the message corresponding to the above Figure 2 Case 1 in the message included in the subtask in step S202.

[0217] It should be noted that the above-mentioned implementation methods 1 and 2 of obtaining a subtask based on the timeout duration in (3) are merely examples and are not specifically limited here. In actual applications, any implementation method that can determine the subtask corresponding to the first message and the subtask corresponding to the second message based on the timeout duration, the time when the first message is received, and the time when the second message is received is within the scope of protection of this application.

[0218] In summary, determining the subtask corresponding to the first message and the subtask corresponding to the second message based on the timeout duration, the time when the first message was received, and the time when the second message was received can utilize the time domain characteristics of the target message set, that is, the burst characteristics of the target message set, to divide multiple message sets in the target message set into an equal number of subtasks. This not only ensures the continuity of the messages in the subtasks, but also provides a basis for subsequent processing and allocation of network resources based on subtask granularity, avoiding the waste of network resources caused by an excessively long time interval between any two adjacent message sets in multiple message sets.

[0219] (4) Obtaining subtasks based on message identifiers

[0220] In some possible implementations, the ingress edge node determines the subtask corresponding to the first message and the subtask corresponding to the second message based on the message identifier carried by the first message and the message identifier carried by the second message. For specific implementations, please refer to the following implementations 1 to 3:

[0221] Implementation method 1: Compare the message identifiers generated by the terminal node in the first message and the second message.

[0222] Specifically, the ingress edge node obtains the message identifiers generated by the terminal node in the first message and the second message, and determines whether the message identifiers generated by the terminal node in the first message and the second message are the same. The message identifier generated by the terminal node includes one or more of the terminal node's IP address, a five-tuple, an application identifier on the terminal node, and a user identifier associated with a user using the terminal node.

[0223] Implementation method 2: Compare the message identifiers generated by the ingress edge node in the first message and the second message.

[0224] Specifically, the ingress edge node obtains a message identifier generated by the ingress edge node in the first message and the second message, and determines whether the message identifiers generated by the ingress edge node in the first message and the second message are the same. The message identifier generated by the ingress edge node includes one or more of a service identifier, a path identifier (such as an identifier of a network node, path selection information, or path constraint information), and a forwarding parameter (such as a time to live (TTL), a quality of service (QoS) parameter, a virtual local area network (VLAN) identifier, or a virtual private network (VPN) parameter).

[0225] Implementation method 3: Compare the message identifiers in the first message and the second message, which are jointly generated by the terminal node and the ingress edge node.

[0226] Specifically, the ingress edge node obtains the message identifiers jointly generated by the terminal node and the ingress edge node in the first message and the second message, and determines whether the message identifiers jointly generated by the terminal node and the ingress edge node in the first message and the second message are the same. The message identifier jointly generated by the terminal node and the ingress edge node can be any combination of the message identifier generated by the terminal node in implementation method 1 of the above-mentioned (4) subtask based on the message identifier acquisition, and the message identifier generated by the ingress edge node in implementation method 2 of the above-mentioned (4) subtask based on the message identifier acquisition.

[0227] In implementation 1, implementation 2, or implementation 3 of (4) obtaining a subtask based on a message identifier, the subtask corresponding to the first message and the subtask corresponding to the second message mainly include the following two situations:

[0228] Case 1: The message identifier carried by the first message is different from the message identifier carried by the second message. The ingress edge node determines that the first message and the second message belong to different subtasks.

[0229] Case 2: The message identifier carried by the first message is the same as the message identifier carried by the second message, and the ingress edge node determines that the first message and the second message belong to the same subtask.

[0230] Therefore, the subtask includes the message corresponding to the above Figure 2 The subtask in step S202 includes case 1 and case 3 in the message.

[0231] It should be noted that the above-mentioned implementations 1 to 3 of (4) for obtaining a subtask based on a message identifier are merely examples and are not specifically limited herein. In practical applications, any implementation that can determine the subtask corresponding to the first message and the subtask corresponding to the second message based on the message identifier carried by the first message and the message identifier carried by the second message are all within the scope of protection of this application.

[0232] It should be noted that the above (1) obtaining subtasks based on interval duration to (4) obtaining subtasks based on message identifiers are only used as examples. The entry edge node can also obtain subtasks from the target message set based on at least two of the interval duration, byte threshold, timeout duration and message identifier in the message segmentation strategy, which is not specifically limited here.

[0233] As an example, the ingress edge node extracts subtasks from the target message set based on the interval duration and the byte threshold. For example, between 23:00 and 7:00, the ingress edge node divides subtasks based on a byte threshold of 20Gbytes; between 7:00 and 15:00, the ingress edge node divides subtasks based on a byte threshold of 10Gbytes.

[0234] As another example, the ingress edge node selects subtasks from the target message set based on the interval duration and message ID. For example, the ingress edge node assigns messages with message ID A1 between 11:00 PM and 7:00 AM to subtask B1, and messages with message ID A2 to subtask B2. The ingress edge node also assigns messages with message ID A1 between 7:00 AM and 3:00 PM to subtask B3, and messages with message ID A2 to subtask B4.

[0235] It should be noted that the above-mentioned entry edge node obtains subtasks from the target message set as an example only. In actual applications, other network nodes (such as exit edge nodes) or terminal nodes can also obtain subtasks from the target message set, including (1) obtaining subtasks based on interval duration to (4) obtaining subtasks based on message identifiers, which are not specifically limited here.

[0236] To sum up, determining the subtask corresponding to the first message and the subtask corresponding to the second message based on the message identifier carried by the first message and the message identifier carried by the second message can provide a basis for subsequently adopting different processing methods for different types of messages to provide better user experience and service quality.

[0237] The following is the above Figure 2 In step S203 , the implementation manner in which the ingress edge node processes the messages included in the message set based on the message processing strategy corresponding to the subtask is specifically introduced.

[0238] (3) How to process messages in subtasks

[0239] The ingress edge node processes the messages in the subtasks in the following ways: (1) counting the messages in the subtask; (2) measuring the messages in the subtask; (3) transmitting the messages in the subtask; and (4) scheduling the messages in the subtask.

[0240] (1) Counting messages in subtasks

[0241] In some possible implementations, the ingress edge node counts the packets in the subtask and obtains the statistical results. For specific implementations, please refer to the following implementation methods 1 and 2:

[0242] Implementation method 1: Use the subtask data as statistical results.

[0243] Exemplarily, the data for a subtask may include one or more of a start time, an end time, a number of messages, and a number of bytes. The start time is the time when the ingress edge node receives the first message in the subtask, where the first message is the earliest message received by the ingress edge node among the messages belonging to the subtask. The end time is the time when the ingress edge node receives the last message in the subtask, where the last message is the latest message received by the ingress edge node among the messages belonging to the subtask. The number of messages is the number of messages in the subtask. The number of bytes is the sum of the lengths of each message in the subtask.

[0244] Implementation method 2: Use the subtask indicators as statistical results. The subtask indicators are calculated based on the subtask data.

[0245] Exemplarily, the indicators of a subtask may include one or more of transmission duration, average throughput, and average rate, etc. The transmission duration is used to indicate the time taken by the entry edge node to transmit all the messages in the subtask, and is calculated based on the start time and the end time. The average throughput is used to indicate the number of messages transmitted by the entry edge node per unit time, and is calculated based on the transmission time and the number of messages. The average rate is used to indicate the amount of data transmitted by the entry edge node per unit time, and is calculated based on the transmission time and the number of bytes.

[0246] After obtaining the statistical results, the ingress edge node can also send the statistical results to the network management tool so that the network management tool can display the statistical graph of the subtask. Figure 1B The NMS mentioned here may also be a network management system, a network controller, a network analyzer, etc., which is not specifically limited here.

[0247] For example, the entry edge node sends the start time, end time and average rate of the subtask as the statistical result to the NMS. The NMS displays the statistical graph of the subtask based on the start time, end time and average rate of the subtask as follows: Figure 3 As shown. Figure 3 In the example, message set M1, message set M2 and message set M3 can be used as a subtask respectively. Figure 3 It is a bar chart containing three subtasks, and, Figure 3 The start time, end time and average rate of each subtask are also shown.

[0248] It should be noted that the above (1) statistical subtasks in which statistical results are obtained based on the subtask data, or statistical results are obtained based on the subtask indicators, are merely examples and are not specifically limited here. In practical applications, any implementation method that can obtain statistical results based on the subtask messages is within the scope of protection of this application.

[0249] In summary, by collecting statistics on the messages in the subtasks and obtaining statistical results, we can use these statistics to understand the current network resource utilization and network performance. Furthermore, we can redeploy network resources based on the statistical results to improve network resource utilization and optimize network performance.

[0250] For example, if the statistical results include the number of packets and the number of bytes, the utilization of network resources can be understood according to the changes in the number of packets and the number of bytes, and the network resources can be redeployed.

[0251] If the number of packets and bytes continues to increase, it means that network resources are fully utilized and the network load is high. You can improve the utilization of network resources by increasing bandwidth, load balancing, optimizing network topology, or optimizing network protocols.

[0252] If the number of packets and bytes continues to decrease, it means that the network resource utilization is low. You can improve the utilization of network resources by reducing bandwidth, allocating network resources on demand, network consolidation, or optimizing network services.

[0253] If the number of packets and bytes suddenly increases, it means that the network is abnormal or under attack, resulting in degraded network performance. You can optimize network performance by updating and strengthening network equipment, filtering and limiting traffic, and performing intrusion detection.

[0254] (2) Messages in the measurement subtask

[0255] In some possible implementations, the ingress edge node adds a measurement identifier to the message in the subtask and performs performance measurement based on the measurement identifier.

[0256] As an example, the measurement identifier may be a coloring, such as RFC8321 Alternate-Marking Method for Passive and Hybrid Performance Monitoring, RFC9341 Alternate-Marking Method for Measuring and Controlling Network Congestion (AMM), or RFC9343 IPv6 Application of the Alternate-Marking Method.

[0257] As another example, the measurement identifier may be a source address and / or an extension header. For example, by encapsulating packets using Segment Routing IPv6 (SRV6) based on the IPv6 forwarding plane, packets in different subtasks may be assigned different source addresses, or different source addresses and different extension headers (such as taskid or taskletid) may be assigned.

[0258] The implementation method of the ingress edge node to perform performance measurement based on the measurement identifier can be seen below. Figure 4A and Figure 4B , and an introduction to related content.

[0259] In a specific implementation, see Figure 4A , Figure 4A This is a flow chart of a performance measurement provided by an embodiment of the present application. Figure 4A As shown, the performance measurement is performed based on the measurement identifier. The specific process is as follows:

[0260] The terminal node sends a message set to the ingress edge node.

[0261] Accordingly, when the ingress edge node receives the first message of the subtask, it triggers the performance measurement of the subtask, including: sending the first message to the central processing unit (CPU) on the ingress edge node for processing, and the CPU sends the performance measurement status. The performance measurement status includes: subtask information, message counter information, and timestamp information. Among them, the subtask information can be a five-tuple or a three-tuple that identifies the subtask. The message counter information can be one or a group of memory addresses, such as the memory address of the number of messages, and the memory address of the number of bytes. The timestamp information can be one or a group of memory addresses, such as the memory address of the starting timestamp (timestamp start, ts_start), and the memory address of the latest message timestamp (timestamp active, ts_active).

[0262] There is a time interval between the CPU of the ingress edge node receiving the first message and sending the performance measurement status. During this period, the CPU of the ingress edge node may receive the second message, the third message, and so on.

[0263] The ingress edge node adds a measurement identifier to the first message, the second message, the third message, etc. of the subtask.

[0264] After the CPU issues the performance measurement status, the ingress edge node begins subtask performance measurement. For the first, second, third, …, n-1th, and nth packets with the same measurement identifier, the ingress edge node records them in the message counter, with the number of packets being n and the number of bytes being X. The ingress edge node then refreshes ts_active to the time when the most recent packet was received. Both n and X are positive integers.

[0265] For ts_start, it can be filled in when the performance measurement status is sent down, or it can be filled in when the first message is received. This is not a specific limitation here. If it is filled in when the first message is received, it is driven by the first message and filled in when the data plane is processed, and it is not refreshed in the process of receiving subsequent messages. Therefore, it is necessary to distinguish between the two states of "not yet filled in / need to be filled in" and "already filled in / no need to refresh". In a specific implementation, the fourth value (such as 0) can be filled in when the performance measurement status is sent down to indicate the state of "not yet filled in / need to be filled in". Then, when the first message is received, the fifth value (such as 1) is filled in to indicate the state of "already filled in / no need to refresh", so that no refresh is performed according to the fifth value during the reception of subsequent messages.

[0266] If no messages are received within a period of time after receiving the nth message, the CPU receives an inactive event and processes it, specifically ending the performance measurement to obtain the performance measurement result of the subtask and refreshing the performance measurement status. Ending the performance measurement to obtain the performance measurement result of the subtask includes setting ts_start and ts_active as the start and end times of the subtask, n and X as the number of messages and bytes of the subtask, respectively, and reporting ts_start, ts_active, n, and X to the NMS. Refreshing the performance measurement status includes setting the fourth value in ts_start so that when the first message of the next subtask is received, the fifth value in ts_start is set.

[0267] The implementation of the above Inactive event can refer to the following implementation method 1 and implementation method 2:

[0268] Implementation method 1: The forwarding chip at the ingress edge node detects the inactive state and sends it to the CPU.

[0269] Implementation method 2: The CPU polls the message counter through a separate process or thread, and sends the corresponding event to the CPU after detecting Inactive.

[0270] In another specific implementation, see Figure 4B , Figure 4BThis is a flow chart of another performance measurement provided by the embodiment of the present application. Figure 4B As shown, the performance measurement is performed based on the measurement identifier. The specific process is as follows:

[0271] The terminal node sends the target message set to the ingress edge node.

[0272] Accordingly, when the ingress edge node receives the first message of the subtask, it triggers the performance measurement of the subtask, including: sending the first message to the CPU for processing, and the CPU sending the performance measurement status.

[0273] The ingress edge node adds a measurement identifier to the first message, the second message, the third message, etc. of the subtask.

[0274] After the CPU issues the performance measurement status, the ingress edge node begins subtask performance measurement. For the first, second, third, …, n-1th, and nth packets with the same measurement identifier, the ingress edge node records them in the message counter, with the number of packets being n and the number of bytes being X. It also refreshes ts_active to the time when the most recent packet was received. Here, n is a positive integer.

[0275] When the ingress edge node receives the first message of the next subtask, it determines that the time difference between ts_active and the current time is greater than or equal to the interval duration having the sixth value. It then terminates the performance measurement of the subtask to obtain the subtask performance measurement result and begins performance measurement of the next subtask. The sixth value is user-defined. Starting performance measurement of the next subtask includes clearing and then updating ts_start and ts_active, and clearing and then accumulating n and X.

[0276] In some possible implementations, the ingress edge node and the egress edge node collaborate to perform performance measurements. Figure 4C — Figure 4G , and an introduction to related content.

[0277] In a specific implementation, see Figure 4C , Figure 4C This is a flowchart of another performance measurement provided in an embodiment of the present application.

[0278] like Figure 4C As shown, the ingress edge node and the egress edge node collaborate to perform performance measurement. The specific process is as follows:

[0279] The terminal node sends a message set to the ingress edge node.

[0280] Accordingly, when the ingress edge node receives the first message of the subtask, it triggers the performance measurement of the subtask, including: sending the first message to the CPU of the ingress edge node for processing, and the CPU of the ingress edge node sends the performance measurement status.

[0281] The ingress edge node adds a measurement identifier to the first message, the second message, the third message, etc. of the subtask.

[0282] After the CPU of the ingress edge node sends the performance measurement status, the ingress edge node starts the performance measurement of the subtask.

[0283] The CPU of the ingress edge node receives the Inactive event, ends the performance measurement of the subtask to obtain the performance measurement result of the subtask, and refreshes the performance measurement state.

[0284] The ingress edge node sends the first, second, and third messages of the subtask to the egress edge node...

[0285] Accordingly, when the egress edge node receives the first message of the subtask, it triggers the performance measurement of the subtask, including: sending the first message to the CPU of the egress edge node for processing, and the CPU of the egress edge node sends the performance measurement status.

[0286] After the CPU of the egress edge node sends the performance measurement status, the egress edge node starts the performance measurement of the subtask.

[0287] The CPU of the egress edge node receives the Inactive event, ends the performance measurement of the subtask to obtain the performance measurement result of the subtask, and refreshes the performance measurement state.

[0288] In another specific implementation, see Figure 4D , Figure 4D This is a flow chart of another performance measurement provided by the embodiment of the present application. Figure 4D As shown, the ingress edge node and the egress edge node collaborate to perform performance measurement. The specific process is as follows:

[0289] The terminal node sends a message set to the ingress edge node.

[0290] Accordingly, when the ingress edge node receives the first message of the subtask, it triggers the performance measurement of the subtask, including: sending the first message to the CPU of the ingress edge node for processing, and the CPU of the ingress edge node sends the performance measurement status.

[0291] After the CPU of the ingress edge node issues the performance measurement status, the ingress edge node waits for an interval with the seventh value, adds measurement flags to the i-th, i+1-th, i+2-th, and so on, packets of the subtask, and begins performance measurement of the subtask. The seventh value is determined by the user.

[0292] The CPU of the ingress edge node receives the Inactive event, ends the performance measurement of the subtask to obtain the performance measurement result of the subtask, and refreshes the performance measurement state.

[0293] The ingress edge node sends the first, second, and third messages of the subtask to the egress edge node...

[0294] Accordingly, when the egress edge node receives the first message of the subtask, it triggers the performance measurement of the subtask, including: sending the first message to the CPU of the egress edge node for processing, and the CPU of the egress edge node sends the performance measurement status.

[0295] After the CPU of the egress edge node issues the performance measurement status, it begins measuring the performance of the subtask based on the measurement identifier. For packets with the same measurement identifier, the egress edge node records the i-th, i+1-th, i+2-th, and so on, in the packet counter, obtaining the number of packets and bytes received. It then updates ts_active to the time when the most recent packet with that measurement identifier was received. i is a positive integer.

[0296] The egress edge node terminates the performance measurement of the subtask based on the measurement identifier to obtain the subtask performance measurement result and refreshes the performance measurement status. Upon receiving a message with a different measurement identifier from the previous message, the egress edge node terminates the performance measurement of the message with the same measurement identifier as the previous message and begins performance measurement of the message with a different measurement identifier.

[0297] In summary, both the ingress edge node and the egress edge node perform performance measurement on the message based on the measurement identifier in the message, which can achieve alignment in performance measurement, that is, it can be ensured that the ingress edge node and the egress edge node measure the message with the same measurement identifier.

[0298] In some possible implementations, the ingress edge node and the egress edge node collaborate to perform performance measurement, including: the ingress edge node sends a first message to the egress edge node. The first message is used to instruct the egress edge node to start performance measurement or send performance measurement results. In addition, the ingress edge node receives a second message sent by the egress edge node. The second message includes the performance measurement results of the egress edge node. For specific implementations, please refer to the following Figure 4E — Figure 4G, and an introduction to related content.

[0299] In a specific implementation, see Figure 4E , Figure 4E This is a flowchart of another performance measurement provided in an embodiment of the present application.

[0300] like Figure 4E As shown, the ingress edge node and the egress edge node collaborate to perform performance measurement. The specific process is as follows:

[0301] The terminal node sends a message set to the ingress edge node.

[0302] Accordingly, when the ingress edge node receives the first message of the subtask, it triggers the performance measurement of the subtask, including: sending the first message to the CPU of the ingress edge node for processing, and the CPU of the ingress edge node sends the performance measurement status.

[0303] The ingress edge node sends the first message of the subtask to the egress edge node.

[0304] Accordingly, when the egress edge node receives the first message of the subtask, it triggers the performance measurement of the subtask, including: sending the first message to the CPU of the egress edge node for processing, and the CPU of the egress edge node sends the performance measurement status.

[0305] After the CPU of the egress edge node sends the performance measurement status, the egress edge node sends a measurement ready notification (MRN) message to the ingress edge node (e.g. Figure 4E This MRN message is used to instruct the ingress edge node to start performance measurement.

[0306] When the ingress edge node receives the MRN message, it adds measurement identifiers to the i-th message, the i+1-th message, the i+2-th message, and so on of the subtask, and starts performance measurement of the subtask. Here, i is a positive integer.

[0307] The ingress edge node sends the i-th message, the i+1-th message, and the i+2-th message with the measurement identifier to the egress edge node.

[0308] The egress edge node performs performance measurement on the message in the subtask according to the measurement identifier.

[0309] The CPU of the ingress edge node receives the Inactive event, ends the performance measurement of the subtask to obtain the performance measurement result of the subtask, and refreshes the performance measurement state.

[0310] When the CPU of the ingress edge node receives the Inactive event, the ingress edge node sends a first message (e.g. Figure 4E The first message is used to instruct the egress edge node to complete the performance measurement of the subtask, obtain the performance measurement result of the subtask, and transmit the performance measurement result. For example, the first message can be a flowlet finish and measurement collection (FFMC) message. The FFMC message can carry a flowlet ID as a subtask identifier to distinguish the subtasks.

[0311] After the egress edge node receives the first message, the egress edge node sends a second message (e.g. Figure 4E The second message includes the performance measurement result of the egress edge node. For example, the second message may be a measurement result report (MRR) message.

[0312] If the ingress edge node does not receive the second message, the ingress edge node repeatedly sends the first message until the ingress edge node receives the second message, that is, the ingress edge node receives the performance measurement result of the egress edge node.

[0313] If the ingress edge node receives the second message, it begins adding measurement identifiers to subsequent packets. Furthermore, based on the performance measurement results from the egress edge node, the ingress edge node can obtain information reflecting network performance, such as the subtask's first packet transmission delay, last packet transmission delay, interval between first and last packets, and subtask's packet loss rate. Furthermore, the ingress edge node can also send information reflecting network performance, such as the subtask's first packet transmission delay, last packet transmission delay, interval between first and last packets, and subtask's packet loss rate, to the NMS.

[0314] In summary, the ingress edge node starts adding measurement identifiers to subsequent messages and performing performance measurements only after receiving the MRN message or the second message, which ensures that the ingress edge node starts performance measurements accurately, reliably, and promptly.

[0315] In another specific implementation, see Figure 4F , Figure 4F This is a flowchart of another performance measurement provided in an embodiment of the present application.

[0316] like Figure 4F As shown, the ingress edge node and the egress edge node collaborate to perform performance measurement. The specific process is as follows:

[0317] The terminal node sends a message set to the ingress edge node.

[0318] Accordingly, when the ingress edge node receives the first message of the subtask, it triggers the performance measurement of the subtask, including: sending the first message to the CPU of the ingress edge node for processing, and the CPU of the ingress edge node sends the performance measurement status.

[0319] After the CPU of the ingress edge node sends the performance measurement status, the ingress edge node sends a first message (e.g. Figure 4F Step-1 in the flow). The first message is used to instruct the egress edge node to start performance measurement of the subtask. In a specific implementation, the first message carries a subtask identifier. The subtask identifier is used to distinguish subtasks. For example, the first message may be a flow measurement start (FMS) message. The FMS message specifies flow characteristics (flowspec) or subtask characteristics (taskspec). The FMS message may carry a flowlet ID as the subtask identifier.

[0320] After the egress edge node receives the first message, it triggers the performance measurement of the subtask, including: sending the first message to the CPU of the egress edge node for processing, and the CPU of the egress edge node sends the performance measurement status.

[0321] When the CPU of the egress edge node sends the performance measurement status, the egress edge node sends an MRN message (such as Figure 4F Step-2 in the previous step).

[0322] If the ingress edge node does not receive the MRN message, the ingress edge node repeatedly sends the first message until the ingress edge node receives the MRN message.

[0323] If the ingress edge node receives the MRN message, it adds measurement identifiers to the i-th message, the i+1-th message, the i+2-th message, etc. of the subtask, and starts performance measurement of the subtask. Here, i is a positive integer.

[0324] The ingress edge node sends the i-th message, the i+1-th message, and the i+2-th message with the measurement identifier to the egress edge node.

[0325] The egress edge node performs performance measurement on the message in the subtask according to the measurement identifier.

[0326] The CPU of the ingress edge node receives the Inactive event, ends the performance measurement of the subtask to obtain the performance measurement result of the subtask, and refreshes the performance measurement state.

[0327] When the CPU of the ingress edge node receives the Inactive event, the ingress edge node sends a first message (e.g. Figure 4F The first message is used to instruct the egress edge node to end the performance measurement of the subtask to obtain the performance measurement result of the subtask, and to send the performance measurement result. For example, the first message can be an FFMC message.

[0328] After the egress edge node receives the first message, the egress edge node sends a second message (e.g. Figure 4F The second message includes the performance measurement result of the egress edge node. For example, the second message may be an MRR message.

[0329] In one specific implementation, the ingress and egress edge nodes each send their own performance measurement results to the NMS. Based on these two performance measurement results, the NMS determines information reflecting network performance, such as the subtask's first packet transmission delay, last packet transmission delay, the interval between the first and last packets, and the subtask's packet loss rate.

[0330] In a more specific implementation, the ingress and egress edge nodes each add a subtask identifier to their respective performance measurement results and send them to the NMS. Based on the two performance measurement results with the same subtask identifier, the NMS determines information reflecting network performance, such as the subtask's first packet transmission delay, last packet transmission delay, the interval between the first and last packets, and the subtask's packet loss rate.

[0331] In summary, the egress edge node can trigger the performance measurement of the subtask according to the first message from the ingress edge node, without triggering the performance measurement of the subtask according to the received message.

[0332] In another specific implementation, see Figure 4G , Figure 4G This is a flow chart of another performance measurement provided by the embodiment of the present application. Figure 4G As shown, the ingress edge node and the egress edge node collaborate to perform performance measurement. The specific process is as follows:

[0333] The terminal node sends a message set to the ingress edge node.

[0334] Accordingly, when the ingress edge node receives the first message of the subtask, it triggers the performance measurement of the subtask, including: sending the first message to the CPU of the ingress edge node for processing, and the CPU of the ingress edge node sends the performance measurement status.

[0335] After the CPU of the ingress edge node sends the performance measurement status, the ingress edge node sends a first message (e.g. Figure 4G The first message is used to instruct the egress edge node to start performance measurement of the subtask. For example, the first message may be an FMS message.

[0336] After the egress edge node receives the first message, it triggers the performance measurement of the subtask, including: sending the first message to the CPU of the egress edge node for processing, and the CPU of the egress edge node sends the performance measurement status.

[0337] When the CPU of the egress edge node sends the performance measurement status, the egress edge node sends an MRN message (such as Figure 4G Step-2 in the previous step).

[0338] When the ingress edge node receives the MRN message, it adds a measurement identifier (such as ID-i) to the i-th message, the i+1-th message, the i+2-th message, etc. of the subtask, and starts performance measurement of messages with the same measurement identifier as the i-th message.

[0339] The ingress edge node sends the i-th message, the i+1-th message, and the i+2-th message with the same measurement identifier to the egress edge node...

[0340] When the ingress edge node adds another measurement identifier (such as ID-j) to the jth message of the subtask, the ingress edge node ends the performance measurement of the message with the same measurement identifier as the i-th message to obtain the performance measurement result of the message with the same measurement identifier as the i-th message, and refreshes the performance measurement state (such as Figure 4G Step-2a in ). Where i < j, and both i and j are positive integers.

[0341] The ingress edge node sends a first message (e.g. Figure 4G (Step-2b in

[0065] ). The first message is used to instruct the egress edge node to terminate performance measurement of a message having the same measurement identifier as the i-th message, to obtain a performance measurement result of the message having the same measurement identifier as the i-th message, and to transmit the performance measurement result of the message having the same measurement identifier as the i-th message. For example, the first message may be an FFMC message.

[0342] After the egress edge node receives the first message, the egress edge node sends a second message (e.g. Figure 4G The second message includes the performance measurement result of the message having the same measurement identifier as the i-th message. For example, the second message may be an MRR message.

[0343] After the ingress edge node receives the second message, based on the performance measurement results of the message with the same measurement identifier as the i-th message from the egress edge node, it can obtain information reflecting network performance (such as the first packet transmission delay, the last packet transmission delay, the interval between the first and last packets, and the message loss rate of the subtask) of the message with the same measurement identifier as the i-th message. Figure 4G Step-2d in the previous step).

[0344] After the ingress edge node adds another measurement identifier to the j-th message of the subtask, the ingress edge node adds the same measurement identifier as the j-th message to the j+1-th message, j+2-th message, j+3-th message, etc. of the subtask, and starts performance measurement of the messages with the same measurement identifier as the j-th message.

[0345] The ingress edge node sends the jth message, j+1th message, j+2th message, and j+3th message with the same measurement identifier to the egress edge node.

[0346] The egress edge node starts performance measurement of the message having the same measurement identifier as the j-th message according to the measurement identifier.

[0347] The CPU of the ingress edge node receives the Inactive event, ends the performance measurement of the subtask to obtain the performance measurement result of the subtask, and refreshes the performance measurement state.

[0348] When the CPU of the ingress edge node receives the Inactive event, the ingress edge node sends a first message (e.g. Figure 4G The first message is used to instruct the egress edge node to end the performance measurement of the subtask to obtain the performance measurement result of the subtask, and to send the performance measurement result of the subtask. For example, the first message can be an FFMC message.

[0349] After the egress edge node receives the first message, the egress edge node sends a second message (e.g. Figure 4G The second message includes the performance measurement result of the egress edge node. For example, the second message may be an MRR message.

[0350] In summary, the ingress edge node can add different measurement identifiers to different packets in the same subtask as needed, and make the egress edge node perform performance measurement on the packets according to the measurement identifiers, so that information reflecting network performance can be obtained as needed. Figure 4G Step-2 in Figure 4GDuring Step 3 of the previous step, the ingress edge node needs to transmit a large number of packets belonging to the same subtask to the egress edge node. The ingress edge node adds different measurement identifiers to different packets belonging to the same subtask and measures the performance of the packets based on the measurement identifiers. This allows the node to obtain information about first-packet transmission delay, packet loss rate, and other conditions at regular intervals.

[0351] It should be noted that the various implementations of performing performance measurement based on the measurement identifier in the message in the measurement subtask (2) described above are merely examples and are not specifically limited herein. In practical applications, any implementation of adding a measurement identifier to the message in the subtask and performing performance measurement based on the measurement identifier is within the scope of protection of this application.

[0352] In summary, by adding measurement identifiers to the messages in the subtasks and performing performance measurements based on the measurement identifiers, we can obtain performance measurement results that reflect network performance. Furthermore, we can redeploy network resources based on the performance measurement results to improve network resource utilization and optimize network performance.

[0353] (3) Transmit the message in the subtask.

[0354] In some possible implementations, the ingress edge node forwards the messages included in the target message set based on the priorities corresponding to the subtasks.

[0355] For example, priorities may include low priority, normal priority, high priority, and urgent priority. Low priority refers to a situation that is neither urgent nor important. Normal priority refers to a situation that is normal and not particularly urgent or important. High priority refers to a situation that is of high urgency or importance. Urgent priority refers to a situation that is of the highest urgency and importance.

[0356] For example, the priority of a subtask depends on the information carried by the message in the subtask. For example, if the message carries email information, the subtask to which the message belongs is set to low priority; if the message carries application information, the subtask to which the message belongs is set to normal priority; if the message carries voice information, the subtask to which the message belongs is set to high priority; if the message carries a distress message, the subtask to which the message belongs is set to emergency priority.

[0357] After determining the priority of the subtask, the ingress edge node determines the packet forwarding policy corresponding to the subtask based on the correspondence between the priority and the packet forwarding policy. The packet forwarding policy is used to indicate how to forward the packet, including one or more of network resources (such as bandwidth and / or transmission rate), routing paths (such as segment routing policy paths), and network slices. A network slice is a virtual network in a packet transmission system.

[0358] The correspondence between the above priorities and packet forwarding policies mainly includes the following two situations:

[0359] Case 1: Different priorities correspond to different packet forwarding strategies.

[0360] Case 2: Different priorities correspond to the same packet forwarding policy.

[0361] Corresponding to the above-mentioned case 1 of the message in the transmission subtask (3), different message forwarding strategies are used to forward messages belonging to subtasks of different priorities.

[0362] For example, different network resources are used to forward messages in different subtasks. Specifically, use poor network resources (such as a transmission rate limited to 2Gbps) to forward messages in low-priority subtasks; use ordinary network resources (such as a transmission rate limited to 4Gbps) to forward messages in normal-priority subtasks; use better network resources (such as a transmission rate limited to 6Gbps) to forward messages in high-priority subtasks; and use the best network resources (such as a transmission rate limited to 9Gbps) to forward messages in urgent-priority subtasks.

[0363] Alternatively, different routing paths or network slices are used to forward packets in different subtasks. Taking network slicing as an example, network slice N1 is used to forward packets in low-priority subtasks; network slice N2 is used to forward packets in normal-priority subtasks; network slice N3 is used to forward packets in high-priority subtasks; and network slice N4 is used to forward packets in urgent-priority subtasks.

[0364] Corresponding to the above-mentioned case 2 of the message in the transmission subtask (3), the same message forwarding strategy is used to forward the messages belonging to the subtasks of different priorities.

[0365] For example, the same network resources are used to forward messages from different subtasks. Specifically, poorer network resources are used to forward messages from low-priority subtasks and messages from normal-priority subtasks, while better network resources are used to forward messages from high-priority subtasks and messages from emergency-priority subtasks.

[0366] Alternatively, the same routing path or network slice can be used to forward packets from different subtasks. Taking network slicing as an example, network slice N1 is used to forward packets from low-priority subtasks and normal-priority subtasks, while network slice N2 is used to forward packets from high-priority subtasks and emergency-priority subtasks.

[0367] It should be noted that the specific content of the priority of the message in the above-mentioned (3) transmission subtask, the basis for determining the priority corresponding to the subtask, and the specific content of the message forwarding strategy are merely examples and are not specifically limited here. In actual applications, any implementation method that can forward the messages included in the target message set based on the priority corresponding to the subtask is within the scope of protection of this application.

[0368] In summary, forwarding the messages included in the target message set based on the priorities of the subtasks can allocate more network resources to higher-priority subtasks and fewer network resources to lower-priority subtasks. This ensures that the messages belonging to higher-priority subtasks can be transmitted more quickly, improving the responsiveness and real-time performance of the network. At the same time, it can also prevent a subtask from occupying too many network resources and hindering the transmission of other subtasks, thereby improving network resource utilization.

[0369] Furthermore, subtask priorities can be dynamically adjusted based on actual network needs. In situations of network congestion or high load, the priority of critical subtasks can be increased to ensure timely transmission of their messages. In situations of network idleness or low load, the priority of non-critical subtasks can be lowered to better utilize bandwidth resources.

[0370] (4) Messages in Scheduling Subtasks

[0371] In some possible implementations, the ingress edge node schedules the messages in the subtasks. The specific implementation can be seen below. Figure 4H , and an introduction to related content.

[0372] See also Figure 4H , Figure 4H This is a flow chart of a scheduling message provided by an embodiment of the present application. Figure 4H As shown in the figure, the ingress edge node schedules the messages in the subtasks. The specific process is as follows:

[0373] The terminal node sends a message set to the ingress edge node.

[0374] Accordingly, when the ingress edge node receives the first message of the subtask, it triggers the performance measurement of the subtask, including: sending the first message to the CPU of the ingress edge node for processing, and the CPU of the ingress edge node sends the performance measurement status.

[0375] After the CPU of the ingress edge node sends the performance measurement status, the ingress edge node sends a first message (e.g. Figure 4H The first message is used to instruct the egress edge node to start performance measurement of the subtask. For example, the first message may be an FMS message.

[0376] After the egress edge node receives the first message, it triggers the performance measurement of the subtask, including: sending the first message to the CPU of the egress edge node for processing, and the CPU of the egress edge node sends the performance measurement status.

[0377] When the CPU of the egress edge node sends the performance measurement status, the egress edge node sends an MRN message (such as Figure 4H Step-2 in the previous step).

[0378] When the ingress edge node receives the MRN message, it adds measurement identifiers to the i-th message, the i+1-th message, the i+2-th message, and so on of the subtask, and starts performance measurement of the subtask. Here, i is a positive integer.

[0379] The ingress edge node sends the i-th message, the i+1-th message, and the i+2-th message with the measurement identifier to the egress edge node.

[0380] The egress edge node performs performance measurement on the message in the subtask according to the measurement identifier.

[0381] The CPU of the ingress edge node receives the Inactive event, ends the performance measurement of the subtask to obtain the performance measurement result of the subtask, and refreshes the performance measurement state.

[0382] When the CPU of the ingress edge node receives the Inactive event, the ingress edge node sends a first message (e.g. Figure 4H The first message is used to instruct the egress edge node to end the performance measurement of the subtask to obtain the performance measurement result of the subtask, and to send the performance measurement result. For example, the first message can be an FFMC message.

[0383] After the egress edge node receives the first message, the egress edge node sends a second message (e.g. Figure 4H The second message includes the performance measurement result of the egress edge node. For example, the second message may be an MRR message.

[0384] When the ingress edge node receives the first packet of the next subtask, it checks the current flow table.

[0385] If there is a flow table that matches the first message, the first message is sent along the flow table.

[0386] If there is no flow table matching the first packet, back pressure is applied directly and the first packet is sent to the CPU of the ingress edge node.

[0387] When the CPU finds a path, it sends the forwarding table of the flow table and releases the back pressure. At the same time, the ingress edge node adds another measurement identifier to the first, second, and third packets of the next subtask, and starts the performance measurement of the next subtask. (e.g. Figure 4H The flow table may include the selection of a forwarding path and may also include performance measurement status.

[0388] The ingress edge node sends the first, second, and third messages with the measurement identifier in the next subtask to the egress edge node...

[0389] The egress edge node performs performance measurement on the message in the next subtask according to the measurement identifier.

[0390] The CPU of the ingress edge node ends the performance measurement of the next subtask by receiving the Inactive event, obtains the performance measurement result of the next subtask, and refreshes the performance measurement status.

[0391] When the CPU of the ingress edge node receives the Inactive event, the ingress edge node sends a first message (e.g. Figure 4H The first message is used to instruct the egress edge node to end the performance measurement of the next subtask, to obtain the performance measurement result of the next subtask, and to send the performance measurement result.

[0392] After the egress edge node receives the first message, the egress edge node sends a second message (e.g. Figure 4H The second message includes the performance measurement result of the egress edge node.

[0393] When the CPU does not find a path, it does not send the flow table, but sends a flow control (FC) message or congestion control (CC) message to the terminal node to enable the terminal node to control the message (such as Figure 4H The FC message or CC message may be one or more of a link-level or network-level (IP) message, a congestion notification protocol (CNP) message and its extensions (such as a CNP congestion status message), and a link-level priority-based flow control (PFC) message.

[0394] In a specific implementation, a network node (such as an ingress edge node) establishes or revokes a flow table and sends it to other network nodes (such as egress edge nodes) through protocols such as Routing Information Protocol (RIP), Border Gateway Protocol (BGP), or Internet Control Message Protocol (ICMP), so that other nodes always have a global flow table.

[0395] In a specific implementation, the aforementioned flow table revocation strategy can use either a "long timeout" or "short timeout" strategy. When the message transmission system transmits a small number of messages, the "long timeout" strategy is implemented by maintaining a fully static path. When the message transmission system transmits a large number of messages, the "short timeout" strategy is implemented through dynamic aging and revocation. This allows the appropriate flow table revocation strategy to be selected based on different application scenarios and network load conditions, thereby improving network efficiency and reliability.

[0396] In summary, by adopting different scheduling methods for messages in different subtasks, flow control and / or congestion control can be achieved.

[0397] It should be noted that the above (1) messages in the statistics subtask to (4) messages in the scheduling subtask are only used as an example. The ingress edge node can also process the messages in the subtask based on at least two of the statistics, measurement, transmission and scheduling in the message processing strategy, which is not a specific limitation here.

[0398] For example, the ingress edge node can count and transmit the messages in the subtask. For example, the ingress edge node counts the number of messages in the subtask, determines the priority of the subtask based on the number of messages in the subtask, and forwards the messages in the subtask based on the priority of the subtask.

[0399] It should be noted that the above-mentioned entry edge node processes the messages in the subtask only as an example. In actual applications, other network nodes (such as exit edge nodes) or terminal nodes can also process the messages in the subtask, including (1) the messages in the statistical subtask - (4) the messages in the scheduling subtask, which is not specifically limited here.

[0400] In some possible implementations, the ingress edge node performs the steps of obtaining the subtask based on the instructions sent by the egress edge node. Figure 4E Step-1 and Step-3 in Figure 4FStep-2 and Step-4 in Figure 4G Step-2 and Step-4 in Figure 4H Step-2, Step-4, and Step-6 in the tutorial, as well as an introduction to related content.

[0401] Below is Figure 4E Step-1 and Step-3 in the example are used to specifically describe the process of the ingress edge node executing the steps of obtaining the subtask based on the instruction sent by the egress edge node.

[0402] Implementation method 1: See Figure 4E In Step-1 of FIG, the egress edge node sends an MRN message to the ingress edge node. The MRN message is used to instruct the ingress edge node to start performance measurement.

[0403] Depend on Figure 4E As can be seen, before executing Step 1, the ingress edge node did not add a measurement identifier to the message and directly sent the message without the measurement identifier to the egress edge node. After executing Step 1, the ingress edge node began adding the measurement identifier to subsequent messages, ensuring that the messages in the subtask have the measurement identifier. Furthermore, the ingress edge node also sends the message with the measurement identifier to the egress edge node, allowing both the ingress edge node and the egress edge node to perform performance measurements based on the measurement identifier.

[0404] Therefore, Step-1 may enable the ingress edge node to execute the steps of obtaining the subtask, and process the message in the subtask based on the message processing strategy corresponding to the subtask.

[0405] Implementation 2: See Figure 4E In Step-3, the egress edge node sends a second message to the ingress edge node. The second message includes a performance measurement result of the egress edge node.

[0406] Depend on Figure 4E As can be seen, before executing Step 3, the ingress edge node repeatedly sends the first message until it receives the second message. After executing Step 3, the ingress edge node receives the second message and then begins adding measurement identifiers to subsequent messages, ensuring that the messages in the subtask have measurement identifiers. Furthermore, the ingress edge node also sends the messages with measurement identifiers to the egress edge node, allowing both the ingress and egress edge nodes to perform performance measurements based on the measurement identifiers.

[0407] Therefore, Step-3 may enable the ingress edge node to execute the steps of obtaining the subtask, and process the message in the subtask based on the message processing strategy corresponding to the subtask.

[0408] It should be noted that the above implementation methods 1 and 2 are merely examples and are not specifically limited herein. In practical applications, any implementation method in which the ingress edge node executes the steps of obtaining the subtask based on the instruction sent by the egress edge node is within the scope of protection of this application.

[0409] The following two configuration examples illustrate the above Figure 2 The message transmission method in is described, including: (1) the first configuration example; (2) the second configuration example.

[0410] (1) First configuration example

[0411] The first configuration example is on an ingress edge node (such as Figure 1A This example shows how to configure target task association, message segmentation strategy, and message processing strategy on L11 in the example. The details are as follows:

[0412] task-based-service##Configure services based on target tasks

[0413] --task-association instance 1##Configure target task association

[0414] ----flow unidir source any dest any vpn-inst vpn1 peer-ip 7.7.7.7##Associate all packets between L11 and L17 with the destination task (instance 1);

[0415] --task dicing-policy ML1##Configure the message division policy;

[0416] ----interval-base 60seconds (interval divided by 1 minute);

[0417] ----volume-base 10Gbytes (divided into 10G bytes intervals);

[0418] ----detection-base timeout 3seconds (divided if timeout is greater than 3 seconds);

[0419] --task service-policy TSP1##Configure the message processing policy;

[0420] ----steering srv6-policy color 1

[0421] ----scheduling DSCP 63

[0422] ----measuring ifit abc##abc is an ifit profile that enables measurement of packets in the subtask.

[0423] --task calendar-policy Night##Configure calendar policy

[0424] ----time 00:01 to 07:59

[0425] --task routing-policy ML1##Configure message processing = target task association + message division policy + message processing policy + calendar policy;

[0426] ----instance 1dicing-policy ML1 service-policy TSP1 calendar-policyNight

[0427] 2) Second configuration example

[0428] The second configuration example is on an ingress edge node (such as Figure 1A An example of configuring target task association, message segmentation strategy, and message processing strategy on L11 in order to implement subtask-level steering. The details are as follows:

[0429] ##Measurement is performed based on the target task association and message partitioning strategy defined below;

[0430] Ifit

[0431] --node-id 1

[0432] --instance 1

[0433] ----flow unidir source any dest any vpn-inst vpn1 peer-ip 7.7.7.7##Configure target task association: Associate all packets between L11 and L17 with the target task (instance 1);

[0434] ----detection-based auto-dicing timeout 3000ms##Configure the message division strategy: divide subtasks based on detection;

[0435] ##Based on the target task association and message division strategy defined below, subtask granularity diversion is achieved;

[0436] Traffic classifier TC1##Configure target task association;

[0437] --flow unidir source any dest any vpn-inst vpn1 peer-ip 7.7.7.7##Associate all packets between L11 and L17 with the target task (instance 1);

[0438] Traffic behavior B1##Configure traffic behavior, including using packet segmentation and traffic diversion strategies (also known as packet processing strategies)

[0439] --detection-based auto-dicing timeout 3000ms##Configure the message division strategy: divide subtasks based on detection;

[0440] --steering-policy color 1##Direct traffic according to subtask granularity;

[0441] Traffic policy P1##Configure traffic policy and use specific traffic behaviors for selected message flows (including subtask division and traffic diversion)

[0442] --classifier ML1 behavior B1

[0443] Interface GigabitEthernet1 / 0 / 0##Enable traffic policy on the interface;

[0444] --traffic-policy p1 inbound

[0445] The above mainly introduces the message transmission method provided by the embodiment of the present application. It is understandable that, in order to realize the corresponding functions mentioned above, each device includes a hardware structure and / or software module corresponding to the execution of each function. Those skilled in the art should easily realize that, in combination with the units and algorithm steps of each example described in the embodiments disclosed herein, the present application can be implemented in the form of hardware or a combination of hardware and computer software. Whether a function is executed in the form of hardware or computer software driving hardware depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of this application.

[0446] The embodiment of the present application can divide the functional modules of the device according to the above method example. For example, each functional module can be divided according to each function, or two or more functions can be integrated into one module. The above integrated modules can be implemented in the form of hardware or in the form of software functional modules. It should be noted that the division of modules in the embodiment of the present application is schematic and is only a logical function division. In actual implementation, there may be other division methods.

[0447] In the case of dividing each functional module into corresponding functional modules, Figure 5 A possible logical structure diagram of a message transmission device is shown. The message transmission device may be an ingress edge node in the above embodiments, or other network nodes (such as egress edge nodes), or terminal nodes. Figure 5 As shown, the message transmission device 500 includes: an acquisition unit 501, a division unit 502 and a processing unit 503.

[0448] The acquiring unit 501 is configured to acquire a message set, which includes one or more messages.

[0449] The division unit 502 is configured to obtain subtasks based on a message division strategy and a message set.

[0450] The processing unit 503 is configured to process the messages included in the message set based on the message processing strategy corresponding to the subtask.

[0451] In some possible implementations, the message segmentation strategy includes at least one of an interval duration, a byte threshold, and a timeout duration.

[0452] In a specific implementation, the message partitioning strategy includes an interval duration, and the message set includes a first message and a second message. The partitioning unit 502 is specifically configured to obtain a time when the first message is received and a time when the second message is received; and based on the interval duration, the time when the first message is received, and the time when the second message is received, determine whether the first message belongs to a subtask, or determine whether the first message and the second message belong to a subtask.

[0453] In another specific implementation, the message partitioning strategy includes a byte threshold, and the message set includes a first message and a second message. The partitioning unit 502 is specifically configured to obtain the number of bytes of the first message and the number of bytes of the second message; and based on the byte threshold, the number of bytes of the first message, and the number of bytes of the second message, determine whether the first message belongs to a subtask, or determine whether the first message and the second message belong to a subtask.

[0454] In another specific implementation, the message partitioning strategy includes a timeout period, and the message set includes a first message and a second message. The partitioning unit 502 is specifically configured to obtain a time when the first message is received and a time when the second message is received; and based on the timeout period, the time when the first message is received, and the time when the second message is received, determine whether the first message belongs to a subtask, or determine whether the first message and the second message belong to a subtask.

[0455] In some possible implementations, the message processing strategy includes at least one of statistics, measurement, and transmission.

[0456] In a specific implementation, the message processing strategy includes statistics. The processing unit 503 is specifically configured to perform statistics on the messages included in the message set corresponding to the subtask and report the statistical results.

[0457] In another specific implementation, the message processing strategy includes measurement. The processing unit 503 is specifically configured to add a measurement identifier to the message included in the message set corresponding to the subtask, and perform performance measurement based on the measurement identifier.

[0458] In another specific implementation, the message processing strategy includes transmission. The processing unit 503 is specifically configured to forward the messages included in the message set based on the priorities corresponding to the subtasks.

[0459] In some possible implementations, the message transmission device 500 further includes an execution unit configured to execute the step of acquiring the subtask based on an instruction sent by the egress edge node.

[0460] In some possible implementations, the message transmission device 500 further includes a sending unit and a receiving unit. The sending unit is configured to send a first message to an egress edge node. The first message is configured to instruct the start of performance measurement or the transmission of performance measurement results. The receiving unit is configured to receive a second message sent by the egress edge node. The second message includes the performance measurement results.

[0461] Figure 5 The specific operation and beneficial effects of each unit in the message transmission device 500 can be found in the above Figure 2 The description of the message transmission method and its possible implementation methods will not be repeated here.

[0462] Figure 6The figure shows a possible hardware structure diagram of a message transmission device provided in an embodiment of the present application. The message transmission device can be any network node or terminal node in the method described in the above embodiment. The network node can be, for example, an ingress edge node or an egress edge node. The message transmission device 600 includes: a processor 601, a memory 602, and a communication interface 603. The processor 601, the communication interface 603, and the memory 602 can be interconnected or connected to each other via a bus 604.

[0463] Exemplarily, the memory 602 is used to store computer programs and data of the message transmission device 600. The memory 602 may include, but is not limited to, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM), or portable compact disc read-only memory (CD-ROM). The communication interface 603 is used to support the message transmission device 600 to communicate, such as receiving or sending data or signals.

[0464] In realizing the aforementioned Figure 2 The message transmission method and its possible implementation method, execute the above Figure 2 The software or program codes required for the functions of all or part of the units in the message transmission method are stored in the memory 602 .

[0465] When implementing any of the above-mentioned embodiments, if the software or program code required for the functions of some units is stored in the memory 602, the processor 601, in addition to calling the program code in the memory 602 to implement some functions, can also cooperate with other components (such as the communication interface 603) to jointly complete other functions described in any of the embodiments (such as the function of receiving and sending data).

[0466] Exemplarily, the processor 601 may be a central processing unit, a general-purpose processor, a digital signal processor, an application-specific integrated circuit, a field programmable gate array or other programmable logic device, a transistor logic device, a hardware component or any combination thereof. The processor may also be a combination that implements computing functions, such as a combination of one or more microprocessors, a combination of a digital signal processor and a microprocessor, etc. The processor 601 may be used to read the program stored in the memory 602 and execute the aforementioned Figure 2 The operations performed by the ingress edge node in the message transmission method.

[0467] Figure 6The specific operations and beneficial effects performed by the message transmission device 600 shown can be found in the aforementioned Figure 2 The description of the message transmission method and its possible implementation methods will not be repeated here.

[0468] The embodiment of the present application also provides a device, which includes a processor, a communication interface and a memory, and is configured to execute the above Figure 2 The message transmission method and the method described in any one of its possible embodiments.

[0469] In one possible implementation, the device is a chip or a system on a chip (SoC).

[0470] The embodiment of the present application also provides a computer-readable storage medium, which stores a computer program, and the computer program is executed by a processor to implement the aforementioned Figure 2 The message transmission method and the method described in any one of its possible embodiments.

[0471] The embodiment of the present application further provides a computer program product. When the computer program product is read and executed by a computer, the aforementioned Figure 2 The method described in any one of the message transmission methods and possible embodiments thereof will be executed.

[0472] The present application also provides a computer program, which, when executed on a computer, enables the computer to implement the aforementioned Figure 2 The message transmission method and the method described in any one of its possible embodiments.

[0473] In this application, the terms "first", "second", etc. are used to distinguish between identical or similar items that have substantially the same role and function. It should be understood that there is no logical or temporal dependency between "first" and "second", nor is there any limitation on quantity or execution order. It should also be understood that although the following description uses the terms first, second, etc. to describe various elements, these elements should not be limited by the terms. These terms are only used to distinguish one element from another. For example, without departing from the scope of the various described examples, a first image can be referred to as a second image, and similarly, a second image can be referred to as a first image. The first image and the second image can both be images, and in some cases, can be separate and different images.

[0474] It should also be understood that in the various embodiments of the present application, the size of the serial number of each process does not mean the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present application.

[0475] It should be understood that determining B based on A does not mean determining B based solely on A. B can also be determined based on A and / or other information.

[0476] It will also be understood that the term “comprise” (also known as “includes,” “including,” “comprises,” and / or “comprising”) when used in this specification specifies the presence of stated features, integers, steps, operations, elements, and / or components, but does not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof.

[0477] It should also be understood that references throughout this specification to "a specific implementation" or "another specific implementation" mean that specific features, structures, or characteristics associated with an embodiment or implementation are included in at least one embodiment of this application. Therefore, the appearance of "a specific implementation" or "another specific implementation" throughout this specification does not necessarily refer to the same embodiment. Furthermore, these specific features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

[0478] It should also be understood that the phrases “when,” “when,” or “if” mentioned throughout this specification all refer to the device performing corresponding processing under certain objective circumstances. They do not limit the time, nor do they require the device to perform a judgment action when it is implemented, nor do they imply the existence of other limitations.

[0479] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some or all of the technical features therein. These modifications or replacements do not deviate the essence of the corresponding technical solutions from the scope of the technical solutions of the embodiments of the present application.

Claims

1. A message transmission method, characterized in that: The method includes: The ingress edge node obtains a message set, where the message set includes one or more messages; The ingress edge node acquires a subtask based on the message partitioning strategy and the message set; The ingress edge node processes the messages included in the message set based on the message processing strategy corresponding to the subtask.

2. The method according to claim 1, characterized in that The message segmentation strategy includes at least one of an interval duration, a byte threshold, and a timeout duration.

3. The method according to claim 1 or 2, characterized in that The message processing strategy includes at least one of statistics, measurement and transmission.

4. The method according to claim 2, characterized in that The message partitioning strategy includes an interval duration, the message set includes a first message and a second message, and the ingress edge node obtains subtasks based on the message partitioning strategy and the message set, including: The ingress edge node obtains a time of receiving the first message and a time of receiving the second message; The ingress edge node determines that the first message belongs to the subtask, or determines that the first message and the second message belong to the subtask based on the interval duration, the time of receiving the first message, and the time of receiving the second message.

5. The method according to claim 2, characterized in that The message segmentation strategy includes a byte threshold, the message set includes a first message and a second message, and the ingress edge node obtains subtasks based on the message segmentation strategy and the message set, including: The ingress edge node obtains the number of bytes of the first message and the number of bytes of the second message; The ingress edge node determines that the first message belongs to the subtask, or determines that the first message and the second message belong to the subtask based on the byte threshold, the number of bytes of the first message, and the number of bytes of the second message.

6. The method according to claim 2, characterized in that The message partitioning strategy includes a timeout period, the message set includes a first message and a second message, and the ingress edge node obtains subtasks based on the message partitioning strategy and the message set, including: The ingress edge node obtains a time of receiving the first message and a time of receiving the second message; The ingress edge node determines that the first message belongs to the subtask, or determines that the first message and the second message belong to the subtask based on the timeout duration, the time of receiving the first message, and the time of receiving the second message.

7. The method according to claim 3, characterized in that The message processing strategy includes statistics, and the ingress edge node processes the messages included in the message set based on the message processing strategy corresponding to the subtask, including: The ingress edge node performs statistics on the messages included in the message set corresponding to the subtask, and reports the statistical results.

8. The method according to claim 3, characterized in that The message processing strategy includes measurement, and the ingress edge node processes the messages included in the message set based on the message processing strategy corresponding to the subtask, including: The ingress edge node adds a measurement identifier to the message included in the message set corresponding to the subtask, and performs performance measurement based on the measurement identifier.

9. The method according to claim 3, characterized in that The message processing strategy includes transmission, and the ingress edge node processes the messages included in the message set based on the message processing strategy corresponding to the subtask, including: The ingress edge node forwards the messages included in the message set based on the priorities corresponding to the subtasks.

10. The method according to any one of claims 1 to 9, characterized in that: The method further comprises: The ingress edge node performs the step of obtaining the subtask based on the instruction sent by the egress edge node.

11. The method according to any one of claims 1 to 9, characterized in that: The method further comprises: The ingress edge node sends a first message to the egress edge node, where the first message is used to instruct to start performance measurement or send a performance measurement result; The ingress edge node receives a second message sent by the egress edge node, where the second message includes the performance measurement result.

12. A message transmission device, characterized in that: The device includes: an acquisition unit, a division unit and a processing unit. The acquiring unit is configured to acquire a message set, where the message set includes one or more messages; The division unit is configured to obtain subtasks based on the message division strategy and the message set; The processing unit is configured to process the messages included in the message set based on the message processing strategy corresponding to the subtask.

13. The device according to claim 12, characterized in that The message segmentation strategy includes at least one of an interval duration, a byte threshold, and a timeout duration.

14. The device according to claim 12 or 13, characterized in that The message processing strategy includes at least one of statistics, measurement and transmission.

15. The device according to claim 13, characterized in that The message division strategy includes an interval duration, the message set includes a first message and a second message, and the division unit is specifically used to obtain the time of receiving the first message and the time of receiving the second message; based on the interval duration, the time of receiving the first message and the time of receiving the second message, determine that the first message belongs to the subtask, or determine that the first message and the second message belong to the subtask.

16. The device according to claim 13, characterized in that The message segmentation strategy includes a byte threshold, the message set includes a first message and a second message, and the segmentation unit is specifically configured to obtain the number of bytes of the first message and the number of bytes of the second message; Based on the byte threshold, the number of bytes of the first message, and the number of bytes of the second message, it is determined that the first message belongs to the subtask, or it is determined that the first message and the second message belong to the subtask.

17. The device according to claim 13, characterized in that The message partitioning strategy includes a timeout period, the message set includes a first message and a second message, and the partitioning unit is specifically used to obtain the time of receiving the first message and the time of receiving the second message; based on the timeout period, the time of receiving the first message and the time of receiving the second message, determine that the first message belongs to the subtask, or determine that the first message and the second message belong to the subtask.

18. The device according to claim 14, characterized in that The message processing strategy includes statistics, and the processing unit is specifically configured to perform statistics on the messages included in the message set corresponding to the subtask and report the statistical results.

19. The device according to claim 14, characterized in that The message processing strategy includes measurement, and the processing unit is specifically configured to add a measurement identifier to the message included in the message set corresponding to the subtask, and perform performance measurement based on the measurement identifier.

20. The apparatus according to claim 14, wherein The message processing strategy includes transmission, and the processing unit is specifically configured to forward the messages included in the message set based on the priorities corresponding to the subtasks.

21. The device according to any one of claims 12 to 20, characterized in that The device further includes: an execution unit, The execution unit is configured to execute the step of obtaining the subtask based on the instruction sent by the egress edge node.

22. The device according to any one of claims 12 to 20, characterized in that The device further includes: a sending unit and a receiving unit, The sending unit is configured to send a first message to the egress edge node, where the first message is used to instruct to start performance measurement or send a performance measurement result; The receiving unit is configured to receive a second message sent by the egress edge node, where the second message includes the performance measurement result.

Images