Operation and maintenance data processing method and system based on cloud network fusion technology

Abstract

The application relates to the technical field of cloud network fusion, in particular to an operation and maintenance data processing method and system based on cloud network fusion technology, which comprises the following steps: according to cloud network edge node monitoring ports, CPU encoding time length, decoding time length and network data packet transmission time length of an IoT gateway are collected; the CPU encoding time length and the decoding time length are operated to obtain total serialization processing time length; and the total serialization processing time length is used as a basis. In the application, for the scene where heat dissipation is limited or voltage is unstable, a high-energy-consumption high-parallelism SIMD operation code is rewritten into a serial operation code, and a no-operation instruction is inserted according to a pipeline duty cycle. The instruction level fine energy efficiency control reduces instantaneous power density and chip heat consumption, ensures that business continuous operation and instruction flow stable throughput are maintained under the condition that the hardware physical boundary is limited, avoids system downtime or performance avalanche caused by overheating protection, and improves the survival ability of edge side equipment under complex working conditions.

Description

Technical Field

[0001] This invention relates to the field of cloud-network convergence technology, and in particular to a method and system for processing operation and maintenance data based on cloud-network convergence technology. Background Technology

[0002] Cloud-network convergence technology involves the deep collaboration and unified orchestration of cloud computing resources and communication network resources. It aims to break down the traditional architectural barriers between computing facilities and communication networks and build an integrated infrastructure architecture of "cloud, edge, and terminal" by utilizing key technologies such as software-defined networking (SDN), network function virtualization (NFV), and edge computing.

[0003] While existing cloud-network converged architectures achieve macro-level coordination of computing and network resources, they lack real-time perception and feedback mechanisms for hardware physical status at the micro-instruction execution level. Resource scheduling strategies often rely on coarse-grained metrics such as general CPU utilization or memory usage, making it difficult to differentiate between serialization computation bottlenecks and network transmission congestion in business processing. This leads to a misalignment between resource allocation strategies and actual business pain points. When edge facilities face voltage fluctuations or heat dissipation bottlenecks, they can only passively defend against these issues by relying on underlying hardware automatic frequency reduction or forced sleep mechanisms. This indiscriminate performance suppression causes all running processes to stutter simultaneously, resulting in latency jitter for critical services. Therefore, improvements are needed. Summary of the Invention

[0004] The purpose of this invention is to address the shortcomings of existing technologies by proposing an operation and maintenance data processing method and system based on cloud-network convergence technology.

[0005] To achieve the above objectives, the present invention adopts the following technical solution: a cloud-network convergence technology-based operation and maintenance data processing method, comprising the following steps: Based on the monitoring port of the cloud network edge node, the CPU encoding time, decoding time and network data packet transmission time of the IoT gateway are collected. The CPU encoding time and decoding time are calculated to obtain the total serialization processing time. Based on the total serialization processing time, the serialization overhead ratio index is calculated and generated. The serialization overhead ratio is compared with the CPU bottleneck threshold and the bandwidth saturation threshold. When the serialization overhead ratio is greater than the CPU bottleneck threshold, the binary protocol source code block is retrieved to generate protocol replacement logic. The protocol replacement logic is combined with the compression code insertion rule triggered by the bandwidth saturation threshold to generate an automatic communication protocol code conversion strategy. Based on the automatic conversion strategy of the communication protocol code, real-time voltage and heat dissipation efficiency data of the base station server are associated to calculate the energy consumption weighted instruction value, and the energy consumption weighted instruction value is mapped to the source code structure branch to generate a green code instruction set mapping matrix. Based on the green code instruction set mapping matrix, the high-parallelism SIMD opcode is rewritten into a serial opcode according to the matrix heat consumption limit, generating a serialized instruction sequence. No-operation instructions are inserted into the serialized instruction sequence according to the pipeline duty cycle to generate a low-heat-consumption energy-efficient executable binary file.

[0006] Preferably, the steps for obtaining the serialization overhead ratio metric are as follows: Based on the continuous collection of CPU encoding time, CPU decoding time and network data packet transmission time of IoT gateway by the monitoring port of cloud network edge node, time alignment verification is performed on the three time items and missing, zero value and abnormal jump records are removed. Only the time items that are valid at the same time within the same monitoring period are retained to obtain the valid time record of port monitoring. Based on the effective duration record of the port monitoring, the CPU encoding duration and CPU decoding duration are merged in the order of the entries and the corresponding network data packet transmission duration is retained synchronously. When the difference between adjacent merged results exceeds the continuity judgment range, linear interpolation smoothing is performed according to the previous and next entries to obtain the total serialization processing duration. The serialization overhead ratio is calculated based on the total serialization processing time and the network data packet transmission time.

[0007] Preferably, the step of obtaining the protocol replacement logic is as follows: Read the serialization overhead ratio, CPU bottleneck threshold, and bandwidth saturation threshold, calculate the difference between the serialization overhead ratio and the CPU bottleneck threshold and bandwidth saturation threshold respectively, generate CPU bottleneck judgment identifier and bandwidth saturation judgment identifier based on the sign of the difference, and construct a threshold comparison judgment identifier set. Based on the threshold comparison and determination flag set, when the CPU bottleneck determination flag is valid, the entry offset of the binary protocol processing function is located, the field with the highest serialization time is identified as the target field, the encoding type mapping relationship of the target field is parsed and replaced with a low-overhead encoding type, and protocol replacement logic is generated.

[0008] Preferably, the step of obtaining the automatic communication protocol code conversion strategy is as follows: Based on the threshold comparison and determination flag set, when the bandwidth saturation determination flag is set, the insertion point of the compression code insertion rule is located. If the protocol replacement logic also exists, the compression code insertion rule and the protocol replacement logic are concatenated in a pipeline order without conflict. If only the bandwidth saturation determination flag exists, an insertion instruction is generated separately to obtain the automatic conversion strategy of communication protocol code.

[0009] Preferably, the step of obtaining the green code instruction set mapping matrix is ​​as follows: Read the protocol replacement logic fragment, compressed code insertion rule fragment, and insertion point identifier set in the automatic conversion strategy of the communication protocol code, extract the target protocol interface name corresponding to the protocol replacement logic fragment, extract the compressed segment boundary identifier corresponding to the compressed code insertion rule fragment, locate and bind the two types of fragments according to the insertion point identifier set, and form a strategy execution binding list. According to the strategy, the binding list is executed, and the real-time voltage data, heat dissipation efficiency data and historical command performance monitoring logs of the associated base station server are associated. The real-time voltage data is segmented according to a unified sampling period and the voltage fluctuation range is extracted. The heat dissipation efficiency data and command performance data are extracted synchronously according to the voltage fluctuation range to generate a hardware and software collaborative range alignment record. The range alignment record corresponding to the specified voltage fluctuation is filtered out according to the voltage fluctuation range. Based on the interval alignment record corresponding to the specified voltage fluctuation, extract the loop unroll count, instruction execution count, real-time voltage value and heat dissipation efficiency value for each interval. Perform pairing operation on the loop unroll count and instruction execution count, and combine the real-time voltage value to calculate the power benchmark. Filter the energy consumption constraints based on the heat dissipation efficiency value and output the energy consumption weighted instruction value. Map the energy consumption weighted instruction value to the source code structure branch to generate the green code instruction set mapping matrix.

[0010] Preferably, the step of obtaining the serialized instruction sequence is as follows: Read the source code structure branch identifier, energy consumption weighted instruction value and matrix heat consumption limit from the green code instruction set mapping matrix. Locate the corresponding instruction block boundary according to the source code structure branch identifier and extract the SIMD opcode list in the instruction block. Call the matrix heat consumption limit to perform threshold filtering on the energy consumption weighted instruction value item by item and mark the instruction block that exceeds the limit, and generate a heat consumption exceeding the limit instruction block marking table.

[0011] Preferably, the step of obtaining the serialized instruction sequence further includes: According to the heat dissipation over-limit instruction block marking table, the marked instruction blocks are opened one by one and the vector width field, parallel channel number field and register allocation field of the SIMD opcode are parsed. The vector width field is split into a scalar operator sequence and the parallel channel number field is rewritten as a single channel. The read and write order is rearranged according to the register allocation field to maintain data dependency consistency, and a serialized instruction sequence is generated.

[0012] Preferably, the step of obtaining the low-heat-consumption energy-efficient executable binary file is as follows: Based on the serialized instruction sequence, the target pipeline duty cycle is calculated according to the proportion by which the energy-weighted instruction value exceeds the matrix heat dissipation limit. The execution cycle attribute of each instruction is extracted. The insertion interval of no-operation instructions is calculated according to the target pipeline duty cycle and no-operation instructions are written at the interval positions. Instruction address relocation is performed and the jump target offset is reconstructed. Linking and binary encapsulation output are completed to generate a low-heat-consumption energy-efficient executable binary file.

[0013] The present invention also provides a system comprising: The data acquisition module is used to collect the CPU encoding time, decoding time and network data packet transmission time of the IoT gateway according to the monitoring port of the cloud network edge node, calculate the CPU encoding time and decoding time to obtain the total serialization processing time, and calculate and generate the serialization overhead ratio index based on the total serialization processing time. The protocol optimization module is used to compare the serialization overhead ratio with the CPU bottleneck threshold and the bandwidth saturation threshold. When the serialization overhead ratio is greater than the CPU bottleneck threshold, the binary protocol source code block is retrieved to generate protocol replacement logic. The protocol replacement logic is combined with the compression code insertion rule triggered by the bandwidth saturation threshold to generate an automatic communication protocol code conversion strategy. The energy consumption analysis module is used to calculate the energy consumption weighted instruction value based on the automatic conversion strategy of the communication protocol code, associate the real-time voltage and heat dissipation efficiency data of the base station server, map the energy consumption weighted instruction value to the source code structure branch, and generate a green code instruction set mapping matrix. The code generation module is used to rewrite the high-parallelism SIMD opcode into a serial opcode according to the green code instruction set mapping matrix and the matrix heat consumption limit, generate a serialized instruction sequence, insert no-operation instructions into the serialized instruction sequence according to the pipeline duty cycle, and generate a low-heat-consumption energy-efficient executable binary file.

[0014] Compared with the prior art, the advantages and positive effects of the present invention are as follows: This invention continuously reads the monitoring ports of cloud network edge nodes, collects the CPU encoding and decoding of IoT gateways and network transmission duration, constructs a serialization overhead ratio index to quantify the deviation between calculation and transmission load, identifies the root cause of resource contention, and compares this index with bottleneck thresholds. The system can dynamically reorganize communication strategies, automatically replace lightweight binary protocol logic when computation is limited, and seamlessly inject compression rules when bandwidth is saturated, realizing adaptive matching of software logic to hardware resources. Real-time voltage and heat dissipation efficiency data of base station servers are introduced as constraints to calculate energy consumption weighted instruction values ​​and map them to the source code structure, establishing a physical environment-aware code generation mechanism. For scenarios with limited heat dissipation or unstable voltage, high-energy-consumption, high-parallelism SIMD opcodes are rewritten as serial opcodes, and no-operation instructions are inserted according to the pipeline duty cycle. This instruction-level fine-grained energy efficiency control reduces instantaneous power density and chip heat dissipation, ensuring that business continuity and stable instruction throughput are maintained even when hardware physical boundaries are limited, avoiding system crashes or performance avalanches due to overheat protection, and improving the survivability of edge devices under complex operating conditions. Attached Figure Description

[0015] Figure 1 This is a schematic diagram of the steps of the present invention. Detailed Implementation

[0016] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention.

[0017] Please see Figure 1 This invention provides a technical solution: a method for processing operation and maintenance data based on cloud-network convergence technology, comprising the following steps: Based on the monitoring ports of the cloud network edge nodes, the CPU encoding time, decoding time, and network data packet transmission time of the IoT gateway are collected. The CPU encoding time and decoding time are calculated to obtain the total serialization processing time. Based on the total serialization processing time, the serialization overhead ratio index is calculated and generated. The serialization overhead ratio is compared with the CPU bottleneck threshold and the bandwidth saturation threshold. When the serialization overhead ratio is greater than the CPU bottleneck threshold, the binary protocol source code block is retrieved to generate protocol replacement logic. The protocol replacement logic is combined with the compression code insertion rule triggered by the bandwidth saturation threshold to generate an automatic communication protocol code conversion strategy. Based on the communication protocol code automatic conversion strategy, real-time voltage and heat dissipation efficiency data of the base station server are associated to calculate the energy consumption weighted instruction value, and the energy consumption weighted instruction value is mapped to the source code structure branch to generate a green code instruction set mapping matrix. Based on the green code instruction set mapping matrix, the high-parallelism SIMD opcode is rewritten into a serial opcode according to the matrix heat consumption limit, generating a serialized instruction sequence. No-operation instructions are inserted into the serialized instruction sequence according to the pipeline duty cycle to generate a low-heat-consumption energy-efficient executable binary file.

[0018] The steps to obtain the serialization cost ratio metric are as follows: Based on the continuous collection of CPU encoding time, CPU decoding time and network data packet transmission time of IoT gateway by the monitoring port of cloud network edge node, time alignment verification is performed on the three time items and missing, zero value and abnormal jump records are removed. Only the time items that are valid at the same time within the same monitoring period are retained to obtain the valid time record of port monitoring. Based on the effective duration record of port monitoring, the CPU encoding duration and CPU decoding duration are merged in the order of the entries and the corresponding network data packet transmission duration is retained synchronously. When the difference between adjacent merged results exceeds the continuity judgment range, linear interpolation smoothing is performed according to the previous and next entries to obtain the total serialization processing duration. The serialization overhead ratio is calculated based on the total serialization processing time and the network data packet transmission time. The formula is as follows: ; in, The serialization overhead ratio is a metric used to characterize the overall cost between serialization computation and network transmission. The total serialization processing time is obtained by adding the CPU encoding time and the CPU decoding time. For network data packet transmission duration, This is a business sensitivity adjustment coefficient, and its value is set based on the sensitivity of the services carried by the cloud network edge nodes to differences in computing and transmission. This indicates the operation of natural exponents.

[0019] Specifically, based on the continuous collection of CPU encoding time, CPU decoding time, and network data packet transmission time from the monitoring port of the cloud network edge node, a non-intrusive hook program is deployed at the underlying driver layer of the edge computing node. This program reads the timestamp counter in the CPU register at millisecond-level frequencies, capturing the clock cycle difference between the entry and completion times of the encoding / decoding task. This difference is then divided by the CPU clock frequency and converted to standard millisecond units to obtain the CPU encoding and decoding times. Simultaneously, the program listens for transmission completion interrupt signals at the data link layer through the network card driver interface, recording the physical transmission time from when the data packet enters the network card's transmit buffer to when an acknowledgment signal is received as the network data packet transmission time. These three types of raw time data are then written to the high-speed... In the circular buffer, the data cleaning logic is initiated, reading the most recent 1,000 historical records in the buffer, calculating the average and standard deviation of each duration, constructing a dynamic valid interval, setting the upper limit of the valid interval to the average plus three times the standard deviation, and the lower limit to the average minus three times the standard deviation. The currently collected duration data is compared with this dynamic valid interval. If the duration data falls outside the interval, it is marked as an abnormal jump record and removed. At the same time, it is checked whether there are zero values ​​or empty fields in the data. Records with zero values ​​are directly discarded. Finally, by comparing the timestamp labels of the three data items, only the data group in which all three data items exist and are valid within the same monitoring period (e.g., a 10-millisecond window) is retained to ensure that the data dimensions of subsequent calculations are aligned, thus obtaining the valid duration records of port monitoring.

[0020] Based on the effective duration records of port monitoring, the CPU encoding duration and CPU decoding duration are merged in order of entry, and the corresponding network data packet transmission duration is retained synchronously. Each row of data in the effective duration records of port monitoring is traversed, and the CPU encoding duration and CPU decoding duration values ​​at the same timestamp are read. An addition operation is performed to accumulate the two values, and the accumulated result is used as the total single-pass serialization time for that entry, while keeping the corresponding network data packet transmission duration unchanged. Then, a continuity check is performed. The records of two adjacent time entries are read, and the time difference between the start time of the latter destination and the end time of the former destination is calculated. A baseline threshold for the continuity judgment range is set. This baseline threshold is obtained by statistically analyzing the average packet interval time of normal business flows over the past hour, and taking 1.2 times this average value as the continuity judgment threshold. The upper limit of the range is set. If the time difference between adjacent entries is less than or equal to this upper limit, the data is considered continuous. If the difference exceeds this continuity determination range, a data gap is identified. At this point, a linear interpolation smoothing mechanism is activated. The total serialization processing time of the valid entries before and after the gap is read. The slope between the two points is calculated using a linear equation, which is to subtract the duration of the previous destination from the duration of the next destination, and then divide the timestamp of the next entry by the timestamp of the previous entry to obtain the rate of change. The estimated duration of the middle moment of the gap is calculated based on this rate of change. The specific calculation expression is that the duration of the gap point is equal to the duration of the previous point plus the rate of change multiplied by the time interval. The calculated interpolated data is filled into the gap to fill the gap in the time series. All the duration data after merging and smoothing are rearranged in chronological order to obtain the total serialization processing time.

[0021] The formula for calculating the serialization overhead ratio addresses the problem that relying solely on a simple ratio cannot reflect the dynamic load imbalance between computation and transmission. In particular, when the difference between the two is small in numerical value but has a non-linear amplified impact on the business, the non-linear characteristics of the exponential function stretch the sensitivity of the index, so that when the serialization computation time slightly exceeds the network transmission time, the index value can respond quickly and rise, thereby triggering operation and maintenance intervention earlier. This design aims to capture the "computation-transmission" collaborative bottleneck and avoid response lag caused by the insensitivity of a simple ratio.

[0022] The total serialization processing time, measured in milliseconds (ms), represents the total computation time required by the CPU to convert raw data into a network-transmittable format and perform the reverse operation when processing a single data packet at the IoT gateway. This parameter is obtained by attaching an eBPF (Extended Berkeley Packet Filter) probe to the entry and exit points of the serialization library functions in the operating system kernel of the cloud network edge node. The nanosecond-level latency of function calls is recorded in real time. Over 500 consecutive business cycles, the encoding and decoding times for each call are accumulated, and the average of these accumulated values ​​is calculated. This average is then converted from nanoseconds to milliseconds and combined with the current CPU load factor (obtained by reading the / proc / stat file) to normalize the base time. The correction formula is the base time multiplied by (1 + current CPU load rate) to eliminate the impact of CPU frequency fluctuations, ultimately yielding the result used for calculation. Numerical values. For example, if the average encoding time is 12ms and the average decoding time is 8ms, and the current CPU load's correction factor for the duration is 1.0 (i.e., no additional load penalty), then... The value was obtained in 20ms.

[0023] This parameter represents the network data packet transmission duration, measured in milliseconds (ms). It characterizes the actual time a data packet occupies within the physical network medium, reflecting the current network bandwidth congestion level and transmission efficiency. The steps to obtain this parameter are as follows: using the hardware timestamp function of the network interface card (NIC) driver layer, record the moment a data frame leaves the NIC's transmission queue. The time when the link layer ACK confirmation frame is received Calculate the difference The data is then uniformly converted to milliseconds. Due to network jitter, at least 1000 data packets need to be sampled for transmission duration within one minute. A histogram of the sample distribution is constructed, and the top 5% and bottom 5% extreme values ​​are removed. The average value is then calculated for the remaining 90% of the sample data. For example, in an actual monitoring case, after removing extreme values ​​from the collected sample set, the calculated average transmission duration was 15ms. The value is 15ms.

[0024] This is a dimensionless service sensitivity adjustment coefficient used to adjust the model's tolerance for differences in computation and transmission latency. Its value typically ranges from 0.5 to 5.0. The steps to obtain this parameter are as follows: Based on the specific service type carried by the cloud network edge node (such as real-time video streams, industrial control signaling, temperature and humidity monitoring data, etc.), conduct service quality degradation tests. In the test environment, manually adjust the ratio of computation latency to transmission latency, record the critical point when the service packet loss rate or screen stuttering rate begins to increase significantly, and then deduce the coefficient based on the critical point. A specific empirical method is as follows: For industrial control services with extremely high real-time requirements, set a high sensitivity, run the test bench continuously for 24 hours, count the number of instruction timeouts caused by latency jitter, construct a mapping curve between latency difference and failure rate, and take the slope corresponding to the point of sudden increase in failure rate as the threshold. Value. For example, for a certain UAV control signaling service, testing has determined that it is extremely sensitive to latency differences, and the measured and calculated values ​​are... The value is 2.5.

[0025] Calculations based on parameters: Substitute the previously obtained parameter values ​​into the formula: , , .

[0026] The first step is to calculate the ratio of total serialization processing time to network data packet transmission time: ; The second step is to calculate the difference ratio term inside the exponential function, that is, the relative difference between the calculation time and the transmission time: ; The third step is to calculate the power of the exponent term and multiply the business sensitivity adjustment coefficient by the relative difference value: ; Fourth step, calculate the value of the natural index: ; The fifth step is to calculate the final serialization cost ratio. Multiply the ratio from the first step by the exponent from the fourth step: ; This result indicates that the current serialization overhead ratio metric The value is 1.9058. This reflects that in the current high-sensitivity business scenario, although the computation time is only about 33% longer than the transmission time, after being exponentially amplified by the business sensitivity coefficient, the overall consumption level index is close to 2.0. If the system's CPU bottleneck threshold is set to 1.8, then the current result of 1.9058 is greater than the threshold of 1.8, which means that the CPU's serialization processing has become the main bottleneck restricting system performance and exceeds the balance range that this type of business can tolerate. The system should immediately trigger the protocol replacement logic to replace the high-overhead serialization protocol with a lighter-weight protocol to reduce... value, thus making It has fallen back to a safe range.

[0027] The steps to obtain the protocol replacement logic are as follows: Read the serialization overhead ratio, CPU bottleneck threshold, and bandwidth saturation threshold, calculate the difference between the serialization overhead ratio and the CPU bottleneck threshold and bandwidth saturation threshold respectively, generate CPU bottleneck judgment flag and bandwidth saturation judgment flag based on the sign of the difference, and construct a threshold comparison judgment flag set. Based on the threshold comparison and identification set, when the CPU bottleneck identification is established, the entry offset of the binary protocol processing function is located, the field with the highest serialization time is identified as the target field, the encoding type mapping relationship of the target field is parsed and replaced with a low-overhead encoding type, and the protocol replacement logic is generated.

[0028] Specifically, the serialization overhead ratio, CPU bottleneck threshold, and bandwidth saturation threshold are read. The serialization overhead ratio, previously calculated to be 1.9058, is retrieved from the shared memory area. Simultaneously, the preset thresholds in the configuration file are retrieved. The CPU bottleneck threshold is set by calculating the average load index of the node under non-congestion conditions over the past month, using the following formula: ,in For average load, To determine the load standard deviation, for example, if the average value is 1.2 and the standard deviation is 0.3, then the CPU bottleneck threshold is set to 1.8. The bandwidth saturation threshold is set based on the physical limits of the link, taking 85% of the network card's maximum throughput as the warning line. For example, the threshold for a gigabit network card is set to 2.5 after conversion. Then, an interpolation calculation is performed, subtracting the CPU bottleneck threshold from the serialization overhead ratio to obtain the first interpolation value. The second difference is obtained by subtracting the bandwidth saturation threshold from the serialization overhead ratio, i.e. Based on the positive and negative characteristics of these two differences, status bits are generated. For the first difference, since the result is greater than zero, it is determined that computing resources are limited, and the CPU bottleneck judgment flag is set to 1. For the second difference, since the result is less than zero, it is determined that bandwidth is sufficient, and the bandwidth saturation judgment flag is set to 0. Finally, these two binary status bits are combined in high and low order, i.e., written into a byte of memory space, with the high bit storing the CPU flag and the low bit storing the bandwidth flag, to obtain the judgment result in binary form and construct a threshold comparison judgment flag set.

[0029] Based on the threshold comparison and identification set, when the CPU bottleneck identification flag is valid, the entry offset of the binary protocol processing function is located, i.e., the read flag bit value is 1. The symbol table parsing engine is started, the ELF format binary file header of the currently running process is read, the section header table is traversed to find the symbol table segment, and the protocol processing function symbol named ProcessPacket is retrieved using a hash matching algorithm to obtain its virtual address offset in the memory segment, for example, 0x401000. Then, the corresponding dynamic performance profiling data is loaded. This data records the serialization instruction cycle number of each substructure inside the function. The time consumption percentage of all fields is sorted in descending order. For example, if the large floating-point array field named SensorData is found to occupy 65% ​​of the serialization time, it is locked as the target field. Then, the pre-built encoding efficiency mapping library is queried. This library defines the CPU consumption weight of different data types under different encoding formats. For example, the weight of JSON format is 10. Protocol The weight of the Buffers format is 2, and the weight of the FlatBuffers format is 1. For the current JSON encoding attribute of the target field, the optimal FlatBuffers low-overhead encoding type is matched, and the corresponding memory operation instruction code block is generated. This code block contains the opcode sequence that replaces the original text-based parsing instructions with direct memory mapping read instructions, and generates protocol replacement logic.

[0030] The steps to obtain the automatic conversion strategy for communication protocol codes are as follows: Based on the threshold comparison and judgment set, when the bandwidth saturation judgment mark is set, the insertion point of the compression code insertion rule is located. If the protocol replacement logic also exists, the compression code insertion rule and the protocol replacement logic are concatenated in pipeline order without conflict. If only the bandwidth saturation judgment mark exists, an insertion instruction is generated separately to obtain the automatic conversion strategy of communication protocol code.

[0031] Specifically, based on the threshold comparison and determination of the identifier set, when the bandwidth saturation determination identifier is true, the insertion point of the compression code insertion rule is located. If the read bandwidth identifier bit is 1, the call stack of the network sending function is scanned, and the buffer pointer position after the data packet is assembled is analyzed using the disassembler engine. This position is marked as the compression entry point, for example, the address before the sendto system call instruction. Then, it is checked whether there is protocol replacement logic generated in the previous step. If so, the dependency conflict of the instruction pipeline needs to be resolved. Following the principle of optimizing data structures first and then compressing the load, a new memory trampoline space is allocated, and the protocol replacement is written first. The instruction sequence of the logic is followed by writing the call instruction of the LZ4 or Zstd real-time compression algorithm at the end address of the replacement logic, and correcting the register state to ensure that the data pointer is correctly passed between the two logic segments. For example, the output buffer address after protocol replacement is loaded into the input register RDI of the compression function. If there is only a bandwidth saturation judgment flag and no protocol replacement logic, an unconditional jump instruction is directly inserted at the original send function entry point to point to the compression code block. Finally, this series of binary machine codes that have undergone address relocation and dependency correction is encapsulated into a patch package that can be directly hot-patched, resulting in the automatic conversion strategy of communication protocol code.

[0032] The steps to obtain the green code instruction set mapping matrix are as follows: Read the protocol replacement logic fragment, compressed code insertion rule fragment, and insertion point identifier set from the automatic conversion strategy of communication protocol code; extract the target protocol interface name corresponding to the protocol replacement logic fragment; extract the compressed segment boundary identifier corresponding to the compressed code insertion rule fragment; locate and bind the two types of fragments according to the insertion point identifier set to form a strategy execution binding list. According to the strategy execution binding list, the real-time voltage data, heat dissipation efficiency data and historical command performance monitoring logs of the base station server are associated. The real-time voltage data is segmented according to a unified sampling period and the voltage fluctuation range is extracted. The heat dissipation efficiency data and command performance data are extracted synchronously according to the voltage fluctuation range to generate a hardware and software collaborative range alignment record. The range alignment record corresponding to the specified voltage fluctuation is filtered out according to the voltage fluctuation range. Based on the interval alignment record corresponding to the specified voltage fluctuation, extract the loop unroll count, instruction execution count, real-time voltage value and heat dissipation efficiency value for each interval. Perform pairing calculations on the loop unroll count and instruction execution count, and combine them with the real-time voltage value to calculate the power benchmark. Filter the energy consumption constraints based on the heat dissipation efficiency value and output the energy consumption weighted instruction value. Map the energy consumption weighted instruction value to the source code structure branch to generate the green code instruction set mapping matrix.

[0033] Specifically, the process reads the protocol replacement logic fragment, compressed code insertion rule fragment, and insertion point identifier set from the automatic conversion strategy of the communication protocol code. It accesses the strategy binary object generated in the previous stage through a memory-mapped interface, uses the specific magic number identifier 0xDEADBEEF to locate the starting address of the protocol replacement logic fragment, parses the header metadata of this fragment to extract the target protocol interface name, such as the "ProcessPacket" function interface determined in the previous steps, and simultaneously scans the instruction stream of the compressed code insertion rule fragment. It identifies the start and end boundaries of the compressed segment by recognizing LZ4 algorithm signatures (such as 0x184D2204). Next, the insertion point identifier set is traversed. This set stores the correspondence between the line number of the source code line and the binary offset. For example, line 128 of the source code corresponds to memory offset 0x00401A20. Based on these offset addresses, the protocol replacement logic fragment and the compression code insertion rule fragment are accurately mounted to the corresponding positions in the target binary file. A doubly linked list structure is constructed for the policy execution binding list. Each node in this list contains three core fields: target address pointer, size of the instruction block to be inserted, and enumeration value of the instruction block type. This ensures that subsequent steps can quickly locate all code regions that need energy efficiency optimization by traversing this list, thus forming the policy execution binding list.

[0034] Based on the policy execution binding list, real-time voltage data, heat dissipation efficiency data, and historical instruction performance monitoring logs of the associated base station server are collected. The output voltage register of the motherboard voltage regulator module (VRM) is read at a sampling frequency of 1 millisecond via the Intelligent Platform Management Interface (IPMI) to obtain a continuous real-time voltage data stream. Simultaneously, the CPU core temperature and fan speed are read via the LMS sensor, and the data is analyzed according to the thermal resistance formula. Real-time calculation of heat dissipation efficiency data (here) For the core temperature, For ambient temperature, (For fan power consumption), and call the performance counter (PMU) to export historical instruction performance monitoring logs containing instruction cycle count (CPI) and cache hit rate. Perform a unified time alignment operation to unify the timestamps of the above three types of data to the nearest whole millisecond. Then, perform sliding window analysis on the real-time voltage data, set the window size to 50 milliseconds, calculate the standard deviation of the voltage values ​​within the window, and set the threshold for judging voltage fluctuations to 0.05 volts. This threshold is set based on 10% of the average voltage drop of the statistical server when switching between idle and full load. When the standard deviation of the voltage within the window is greater than 0.05 volts, this time period is marked as a voltage fluctuation range. The corresponding heat dissipation efficiency and instruction performance data are extracted according to this range to construct a joint dataset containing voltage fluctuation characteristics, heat dissipation status and instruction execution characteristics. This generates interval-aligned records that are coordinated by hardware and software. Finally, these records are traversed, and records with voltage fluctuation amplitudes between 0.1 volts and 0.2 volts are filtered out. This range is defined as "specified voltage fluctuation", which represents a typical operating condition with high load and energy efficiency sensitivity. The interval-aligned records corresponding to the specified voltage fluctuation are filtered out based on the voltage fluctuation range.

[0035] Based on the alignment record corresponding to the specified voltage fluctuation interval, extract the loop unroll count, instruction execution count, real-time voltage value, and heat dissipation efficiency value for each interval. Parse the loop unroll count of the current code block during the compiler optimization phase from the instruction performance log associated with the alignment record; for example, if a loop is unrolled 4 times. Extract the actual instruction execution count submitted by the CPU within that time slice, for example, 200 instructions. Read the real-time voltage value at that moment, such as 1.15 volts, and the heat dissipation efficiency value, such as 0.85 (i.e., 85% heat conduction efficiency). Substitute these physical parameters into the energy consumption weighted instruction value calculation formula. This formula, based on the CMOS dynamic power consumption principle, is used to evaluate the instruction execution cost. The calculation formula is as follows: ,in, The energy-weighted instruction value is a dimensionless energy efficiency cost index used to characterize the overall energy cost of the instruction block under current voltage and heat dissipation conditions. The loop unrolling counter is derived from the compiler log; in this example, it is 4. The instruction execution count, derived from PMU records, is 200 in this example. The product of the two represents the total amount of flipping activity. This is a real-time voltage value in volts (V), 1.15 in this example. This is the voltage compliance index, set to 2 based on the physical characteristics of integrated circuits, representing that power consumption is proportional to the square of the voltage. This represents the heat dissipation efficiency value, ranging from 0 to 1. In this example, it is 0.85. As a denominator term, it indicates that the lower the heat dissipation efficiency, the greater the weight of the energy consumption cost. The effective switching capacitor coefficient is the unit instruction, and the unit is... (Normalization constant), used to map the number of logic gate flips to the equivalent capacitive load. Based on the average standard cell capacitance characteristics of the 7nm process node, it was determined through SPICE simulation and normalized to 0.015. Calculations were performed based on the parameters: The first step is to calculate the total logical flip activity: ; The second step is to calculate the power consumption weighting term for the voltage: ; The third step is to calculate the correction factor that includes the heat dissipation penalty (rounded to four decimal places): ; Step 4: Calculate the weighted energy consumption command value. ; The result shows that the current code block's energy-weighted instruction value is 18.6708. This value quantifies the overall energy efficiency cost of executing 800 equivalent logic operations under conditions of 1.15V high voltage and imperfect heat dissipation efficiency (85%). If the system's preset matrix heat dissipation limit (energy consumption warning threshold) is 15.0, which is calculated based on a 20% increase in baseline energy consumption under standard voltage (1.0V) and ideal heat dissipation (95%) conditions, then the current calculation result of 18.6708 is significantly higher than the threshold of 15.0. This means that the instruction block belongs to "hot spot code," and its execution under the current hardware environment will lead to a sharp drop in energy efficiency. The system must serialize and rewrite it to reduce concurrency, mapping the calculation result to the source code structure branch to generate a green code instruction set mapping matrix.

[0036] The steps for obtaining the serialized instruction sequence are as follows: Read the source code structure branch identifier, energy consumption weighted instruction value and matrix heat consumption limit in the green code instruction set mapping matrix. Locate the corresponding instruction block boundary according to the source code structure branch identifier and extract the SIMD opcode list in the instruction block. Call the matrix heat consumption limit to perform threshold filtering on the energy consumption weighted instruction value and mark the instruction block that exceeds the limit. Generate a heat consumption over-limit instruction block marking table. Based on the instruction block marking table for exceeding heat dissipation limits, each marked instruction block is opened and the vector width field, parallel channel number field, and register allocation field of the SIMD opcode are parsed. The vector width field is split into a scalar operator sequence and the parallel channel number field is rewritten as a single channel. The read and write order is rearranged according to the register allocation field to maintain data dependency consistency, thus generating a serialized instruction sequence.

[0037] Specifically, the code reads the source code structure branch identifier, energy-weighted instruction value, and matrix thermal dissipation limit from the green code instruction set mapping matrix. It then uses a hash index to quickly retrieve the mapping matrix data structure stored in shared memory, extracting the previously calculated energy-weighted instruction value of 18.6708. Finally, it calls the preset matrix thermal dissipation limit of 15.0. This limit is set based on the upper limit of safe heat flux density under the chip's thermal design power (TDP), for example, the maximum allowable average power consumption on a 1 square millimeter silicon wafer area is 15 normalized units. Next, based on the source code structure branch identifier, such as "Func_Process_Block_A", it queries the DWARF debug information file generated by the compiler. The `.debug_line` segment is parsed to reveal the start address (0x00401000) and end address (0x004010FF) of the function block in the binary file, thus accurately locating the corresponding instruction block boundary. The machine code stream within this address range is traversed, and the x86-64 instruction set encoding is matched byte-by-byte using the disassembler engine. All AVX / AVX2 instructions encoded with the VEX prefix are identified, and a list of SIMD opcodes such as VMULPS and VADDpd is extracted. Subsequently, threshold filtering logic is executed, comparing the energy-weighted instruction value with the matrix heat dissipation limit. Since 18.6708 is greater than 15.0, the instruction block is determined to be a hotspot region, and the over-limit magnitude is calculated using the following formula: ,in, The "over-limit range" is used to quantify the percentage by which the energy consumption of the current instruction block exceeds the safe range. This is the energy consumption weighted instruction value, which is 18.6708. To limit the matrix heat dissipation, a value of 15.0 is used. Substituting this value into the calculation yields... If the thermal dissipation exceeds the limit by 24.47%, the starting address, length, and extent of the exceedance of the instruction block are encapsulated into a record and written into the thermal dissipation exceedance instruction block mark table. This table uses a bitmap index structure to optimize the subsequent fast lookup performance and generates the thermal dissipation exceedance instruction block mark table.

[0038] Based on the instruction block marking table for exceeding thermal dissipation limits, each marked instruction block is opened one by one, and the vector width field, parallel channel number field, and register allocation field of the SIMD opcode are parsed. The memory address marked in the bitmap index is read, and the corresponding binary instruction data is loaded. For each SIMD instruction, such as "vmulps ymm1, ymm2, ymm3", the VEX prefix byte in its machine code is parsed, and the L bit (vector length) of 1 indicates a 256-bit width. The parallel channel number field is identified as 8 (i.e., processing 8 single-precision floating-point numbers simultaneously). At the same time, the ModR / M byte is parsed to obtain the register allocation, i.e., the source registers are ymm2 and ymm3, and the destination register is ymm1. Then, serialization is performed to decompose the original single-cycle 256-bit parallel operation into 8 consecutive 32-bit scalar operations. The parallel channel number field is rewritten, and the opcode is replaced from vector multiplication "vmulps" to scalar multiplication "mul". The system uses the "ss" instruction and performs register renaming and stack overflow handling based on the register allocation field. It constructs a data dependency graph (DDG) to analyze the read and write order. For example, it introduces a temporary stack space [rsp+offset] to simulate the high-order data storage of the original vector register, ensuring that the split scalar instruction sequence strictly follows the original data flow order in logic. This prevents data races or calculation result deviations caused by instruction reordering. Finally, the eight "mulss" instructions and the necessary "movss" data moving instructions are combined in sequence to replace the original single SIMD instructions and generate a serialized instruction sequence.

[0039] The steps to obtain a low-heat-consumption, energy-efficient executable binary file are as follows: Based on the serialized instruction sequence, the target pipeline duty cycle is calculated according to the proportion by which the energy-weighted instruction value exceeds the matrix heat dissipation limit. The execution cycle attribute of each instruction is extracted. The insertion interval of no-operation instructions is calculated according to the target pipeline duty cycle and no-operation instructions are written at the interval positions. Instruction address relocation is performed and the jump target offset is reconstructed. Linking and binary encapsulation output are completed to generate a low-heat-consumption and energy-efficient executable binary file.

[0040] Specifically, based on the serialized instruction sequence, the target pipeline duty cycle is calculated according to the proportion by which the energy-weighted instruction value exceeds the matrix heat dissipation limit. The execution cycle attribute of each instruction is extracted. Based on the over-limit range calculated in paragraph 1, the cooling target is set to reduce the energy consumption per unit time to below the limit value. First, the target pipeline duty cycle is calculated using the following formula: ,in, The target pipeline duty cycle represents the proportion of time the CPU spends executing valid instructions per unit of time. The matrix heat dissipation limit is 15.0. Substituting the energy-weighted command value (18.6708) into the calculation yields... That is, the effective working time should be controlled at around 80.3%, with the remaining approximately 19.7% being forced cooling time. Next, consult the instruction latency table in the processor architecture manual to extract the execution cycle attribute of each scalar instruction in the serialized sequence. For example, the average execution cycle of the "mulss" instruction is 4 clock cycles. Calculate the insertion interval of no-operation instructions using the following formula: ,in, The insertion interval indicates how many clock cycles of valid instructions must be executed before a no-operation is inserted. The average execution cycle of the current instruction is 4, which is taken here. This represents the percentage of cooldown time; substituting this into the calculation yields... That is, after each effective instruction is executed for about 16 clock cycles, a no-operation (NOP) instruction needs to be inserted. 0x90 (NOP opcode) is written to the corresponding byte position in the serialized instruction sequence. After the insertion, due to the increase in the total instruction length, the physical address of subsequent instructions is offset. It is necessary to traverse all relative jump instructions (such as jmp, call) in the code segment, recalculate the jump target offset based on the number of inserted bytes, correct the address mapping in the symbol table, and finally call the linker to re-merge the modified code segment with the original data segment, update the entry point and checksum in the ELF file header, complete the linking and binary encapsulation output, and generate a low-thermal-power-efficiency executable binary file.

[0041] The above are merely preferred embodiments of the present invention and are not intended to limit the present invention in any other way. Any person skilled in the art may make changes or modifications to the above-disclosed technical content to create equivalent embodiments that can be applied to other fields. However, any simple modifications, equivalent changes, and modifications made to the above embodiments based on the technical essence of the present invention without departing from the scope of the present invention shall still fall within the protection scope of the present invention.

Claims

1. A method for processing operation and maintenance data based on cloud-network convergence technology, characterized in that, Includes the following steps: Based on the monitoring port of the cloud network edge node, the CPU encoding time, decoding time and network data packet transmission time of the IoT gateway are collected. The CPU encoding time and decoding time are calculated to obtain the total serialization processing time. Based on the total serialization processing time, the serialization overhead ratio index is calculated and generated. The serialization overhead ratio is compared with the CPU bottleneck threshold and the bandwidth saturation threshold. When the serialization overhead ratio is greater than the CPU bottleneck threshold, the binary protocol source code block is retrieved to generate protocol replacement logic. The protocol replacement logic is combined with the compression code insertion rule triggered by the bandwidth saturation threshold to generate an automatic communication protocol code conversion strategy. Based on the automatic conversion strategy of the communication protocol code, real-time voltage and heat dissipation efficiency data of the base station server are associated to calculate the energy consumption weighted instruction value, and the energy consumption weighted instruction value is mapped to the source code structure branch to generate a green code instruction set mapping matrix. Based on the green code instruction set mapping matrix, the high-parallelism SIMD opcode is rewritten into a serial opcode according to the matrix heat consumption limit, generating a serialized instruction sequence. No-operation instructions are inserted into the serialized instruction sequence according to the pipeline duty cycle to generate a low-heat-consumption energy-efficient executable binary file.

2. The operation and maintenance data processing method based on cloud-network convergence technology according to claim 1, characterized in that, The steps for obtaining the serialization overhead ratio metric are as follows: Based on the continuous collection of CPU encoding time, CPU decoding time and network data packet transmission time of IoT gateway by the monitoring port of cloud network edge node, time alignment verification is performed on the three time items and missing, zero value and abnormal jump records are removed. Only the time items that are valid at the same time within the same monitoring period are retained to obtain the valid time record of port monitoring. Based on the effective duration record of the port monitoring, the CPU encoding duration and CPU decoding duration are merged in the order of the entries and the corresponding network data packet transmission duration is retained synchronously. When the difference between adjacent merged results exceeds the continuity judgment range, linear interpolation smoothing is performed according to the previous and next entries to obtain the total serialization processing duration. The serialization overhead ratio is calculated based on the total serialization processing time and the network data packet transmission time.

3. The operation and maintenance data processing method based on cloud-network convergence technology according to claim 1, characterized in that, The steps for obtaining the protocol replacement logic are as follows: Read the serialization overhead ratio, CPU bottleneck threshold, and bandwidth saturation threshold, calculate the difference between the serialization overhead ratio and the CPU bottleneck threshold and bandwidth saturation threshold respectively, generate CPU bottleneck judgment identifier and bandwidth saturation judgment identifier based on the sign of the difference, and construct a threshold comparison judgment identifier set. Based on the threshold comparison and determination flag set, when the CPU bottleneck determination flag is valid, the entry offset of the binary protocol processing function is located, the field with the highest serialization time is identified as the target field, the encoding type mapping relationship of the target field is parsed and replaced with a low-overhead encoding type, and protocol replacement logic is generated.

4. The operation and maintenance data processing method based on cloud-network convergence technology according to claim 1, characterized in that, The steps for obtaining the automatic communication protocol code conversion strategy are as follows: Based on the threshold comparison and determination flag set, when the bandwidth saturation determination flag is set, the insertion point of the compression code insertion rule is located. If the protocol replacement logic also exists, the compression code insertion rule and the protocol replacement logic are concatenated in a pipeline order without conflict. If only the bandwidth saturation determination flag exists, an insertion instruction is generated separately to obtain the automatic conversion strategy of communication protocol code.

5. The operation and maintenance data processing method based on cloud-network convergence technology according to claim 1, characterized in that, The steps for obtaining the green code instruction set mapping matrix are as follows: Read the protocol replacement logic fragment, compressed code insertion rule fragment, and insertion point identifier set in the automatic conversion strategy of the communication protocol code, extract the target protocol interface name corresponding to the protocol replacement logic fragment, extract the compressed segment boundary identifier corresponding to the compressed code insertion rule fragment, locate and bind the two types of fragments according to the insertion point identifier set, and form a strategy execution binding list. According to the strategy, the binding list is executed, and the real-time voltage data, heat dissipation efficiency data and historical command performance monitoring logs of the associated base station server are associated. The real-time voltage data is segmented according to a unified sampling period and the voltage fluctuation range is extracted. The heat dissipation efficiency data and command performance data are extracted synchronously according to the voltage fluctuation range to generate a hardware and software collaborative range alignment record. The range alignment record corresponding to the specified voltage fluctuation is filtered out according to the voltage fluctuation range. Based on the interval alignment record corresponding to the specified voltage fluctuation, extract the loop unroll count, instruction execution count, real-time voltage value and heat dissipation efficiency value for each interval. Perform pairing operation on the loop unroll count and instruction execution count, and combine the real-time voltage value to calculate the power benchmark. Filter the energy consumption constraints based on the heat dissipation efficiency value and output the energy consumption weighted instruction value. Map the energy consumption weighted instruction value to the source code structure branch to generate the green code instruction set mapping matrix.

6. The operation and maintenance data processing method based on cloud-network convergence technology according to claim 1, characterized in that, The steps for obtaining the serialized instruction sequence are as follows: Read the source code structure branch identifier, energy consumption weighted instruction value and matrix heat consumption limit from the green code instruction set mapping matrix. Locate the corresponding instruction block boundary according to the source code structure branch identifier and extract the SIMD opcode list in the instruction block. Call the matrix heat consumption limit to perform threshold filtering on the energy consumption weighted instruction value item by item and mark the instruction block that exceeds the limit, and generate a heat consumption exceeding the limit instruction block marking table.

7. The operation and maintenance data processing method based on cloud-network convergence technology according to claim 6, characterized in that, The step of obtaining the serialized instruction sequence further includes: According to the heat dissipation over-limit instruction block marking table, the marked instruction blocks are opened one by one and the vector width field, parallel channel number field and register allocation field of the SIMD opcode are parsed. The vector width field is split into a scalar operator sequence and the parallel channel number field is rewritten as a single channel. The read and write order is rearranged according to the register allocation field to maintain data dependency consistency, and a serialized instruction sequence is generated.

8. The operation and maintenance data processing method based on cloud-network convergence technology according to claim 1, characterized in that, The steps for obtaining the low-heat-consumption energy-efficient executable binary file are as follows: Based on the serialized instruction sequence, the target pipeline duty cycle is calculated according to the proportion by which the energy-weighted instruction value exceeds the matrix heat dissipation limit. The execution cycle attribute of each instruction is extracted. The insertion interval of no-operation instructions is calculated according to the target pipeline duty cycle and no-operation instructions are written at the interval positions. Instruction address relocation is performed and the jump target offset is reconstructed. Linking and binary encapsulation output are completed to generate a low-heat-consumption energy-efficient executable binary file.

9. The system for processing operation and maintenance data based on cloud-network convergence technology according to any one of claims 1-8, characterized in that, include: The data acquisition module is used to collect the CPU encoding time, decoding time and network data packet transmission time of the IoT gateway according to the monitoring port of the cloud network edge node, calculate the CPU encoding time and decoding time to obtain the total serialization processing time, and calculate and generate the serialization overhead ratio index based on the total serialization processing time. The protocol optimization module is used to compare the serialization overhead ratio with the CPU bottleneck threshold and the bandwidth saturation threshold. When the serialization overhead ratio is greater than the CPU bottleneck threshold, the binary protocol source code block is retrieved to generate protocol replacement logic. The protocol replacement logic is combined with the compression code insertion rule triggered by the bandwidth saturation threshold to generate an automatic communication protocol code conversion strategy. The energy consumption analysis module is used to calculate the energy consumption weighted instruction value based on the automatic conversion strategy of the communication protocol code, associate the real-time voltage and heat dissipation efficiency data of the base station server, map the energy consumption weighted instruction value to the source code structure branch, and generate a green code instruction set mapping matrix. The code generation module is used to rewrite the high-parallelism SIMD opcode into a serial opcode according to the green code instruction set mapping matrix and the matrix heat consumption limit, generate a serialized instruction sequence, insert no-operation instructions into the serialized instruction sequence according to the pipeline duty cycle, and generate a low-heat-consumption energy-efficient executable binary file.

Images