Method for compressing monitoring data of an FC network switch

Abstract

The application provides a compression method of FC network switch monitoring data, comprising the following steps: dividing the monitoring data of FC network switch into a fixed field H and a payload P; initializing a knowledge base L and a compiling table D according to the format defined by FC frame protocol, wherein the compiling table D is used for saving all roots in the payload P, and the knowledge base L is used for converting the subfield in the fixed field H into a set encoding value; compressing the fixed field H into a first compressed encoding stream according to the knowledge base L; compressing the payload P into a second compressed encoding stream according to the compiling table D; and generating the compressed monitoring data by splicing the first compressed encoding stream and the second compressed encoding stream. The knowledge base L and the compiling table D are established, and a shorter code is used to represent a longer string, so that the compression of FC network switch monitoring data is realized.

Description

Technical Field

[0001] This invention relates to the field of data compression technology, and specifically to a method for compressing monitoring data from an FC network switch. Background Technology

[0002] In airborne avionics systems, real-time monitoring and proper storage of data frames transmitted in the FC network are crucial for data debugging and analysis. Monitoring and recording this traffic allows for network fault diagnosis and location during ground-based debugging. However, due to the high communication speed and large data volume of the FC network, coupled with the limited storage space of the monitoring card, it is necessary to maximize storage utilization and minimize resource waste. To efficiently utilize limited bandwidth resources, efficient algorithms and data structures are required to compress FC network traffic. By reducing network data compression, the volume of data can be significantly reduced, thereby lowering storage costs.

[0003] However, there is currently no effective compression method for compressing data frames. Summary of the Invention

[0004] In view of this, embodiments of this specification provide a method for compressing monitoring data of an FC network switch. This method achieves adaptive improvements to the LZW algorithm, a dictionary-based compression technique, which helps reduce data volume in the face of the complexity of large-scale deployments in high-speed networks. It also possesses scalability and adaptability, ensuring that data transmission meets the requirements of real-time communication.

[0005] The embodiments in this specification provide the following technical solutions:

[0006] A method for compressing monitoring data from an FC network switch includes:

[0007] The monitoring data of the FC network switch is divided into fixed fields H and load P;

[0008] The knowledge base L is initialized according to the format defined by the FC frame protocol, and the compilation table D is initialized. The compilation table D is used to store all the roots in the payload P, and the knowledge base L is used to convert the subfields in the fixed field H into the set encoded values.

[0009] Based on the knowledge base L, the fixed field H is compressed into a first compressed encoded stream;

[0010] The payload P is compressed into a second compressed encoded stream according to the compilation table D;

[0011] The first compressed encoded stream and the second compressed encoded stream are concatenated to generate compressed monitoring data.

[0012] Furthermore, the knowledge base L is initialized according to the format defined by the FC frame protocol, including:

[0013] According to the format defined by the FC frame protocol, the monitoring data is divided into multiple protocol fields. Each protocol field includes multiple sets of field explanations, and each set of field explanations includes the field content and the corresponding encoded value.

[0014] After setting the corresponding encoding value for each field, the protocol field, field content, and encoding value are saved to the knowledge base L.

[0015] Further, initialize compilation table D, including:

[0016] Use the hexadecimal numbers from 0 to 255 as the initial roots, and use the sequential number of the initial roots as the index number;

[0017] Save the initial root and its corresponding index to compilation table D.

[0018] Furthermore, based on the knowledge base L, the fixed field H is compressed into a first compressed encoded stream, including:

[0019] The fixed field H is divided into multiple subfields according to the protocol format definition of the FC frame;

[0020] Process all subfields in a loop until all subfields have been processed. Then concatenate the compressed codes generated for each subfield to generate the first compressed encoded stream.

[0021] Based on the protocol format definition, determine the protocol field to which the subfield belongs;

[0022] In knowledge base L, based on the protocol field, query the field content that matches the subfield and the corresponding encoded value of the field content. If a matching field content is found, the encoded value is output as a compressed encoding.

[0023] Furthermore, it also includes:

[0024] If no matching field content can be found, set the corresponding encoding value for the current subfield;

[0025] The protocol field, subfield, and set encoding value corresponding to the current subfield are respectively used as the protocol field, field content, and encoding value in knowledge base L, and then appended to knowledge base L.

[0026] Furthermore, the payload P is compressed into a second compressed encoded stream according to the compilation table D, including:

[0027] Furthermore, the payload P is compressed into a second compressed encoded stream according to the compilation table D, including:

[0028] Read the first character in the payload P, obtain the index number corresponding to the first character from the compilation table D, and use the index number as the second compression code;

[0029] Read all characters in payload P sequentially after the first character until all characters in payload P are converted to the second compression code, and then concatenate all the second compression codes in order to generate the second compression code stream:

[0030] The character read is taken as the first character, and the character after the first character is taken as the second character;

[0031] Concatenate the first character and the second character to form the middle character, and determine whether the middle character is in the compilation table D;

[0032] If the middle character is in compilation table D, obtain the index number corresponding to the middle character from compilation table D, and use the index number as the second compression code.

[0033] Furthermore, it also includes:

[0034] If the middle character is not in compilation table D, add the middle character as a new root to compilation table D and assign a new index number to the new root;

[0035] Use the new index number as the second compression code.

[0036] Furthermore, it also includes:

[0037] If the first character or the middle character is not in the compilation table D, add the first character or the middle character as a new root to the compilation table D, and assign a new index number to the new root;

[0038] Use the new index number as the second compression code.

[0039] Compared with the prior art, the beneficial effects that at least one technical solution adopted in the embodiments of this specification can achieve include at least:

[0040] Compression is achieved by establishing a knowledge base L and a compilation table D, using shorter codes to represent longer strings. The basic principle is to extract different characters from the original file data, create a compilation table based on these characters, and then use the character indices in the compilation table to replace the corresponding characters in the original file data, thus reducing the size of the original data. Attached Figure Description

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

[0042] Figure 1 This is a flowchart of a method for compressing monitoring data of an FC network switch according to an embodiment of the present invention. Detailed Implementation

[0043] The embodiments of this application will now be described in detail with reference to the accompanying drawings.

[0044] It should be noted that, unless otherwise specified, the embodiments and features described in this application can be combined with each other. The present invention will now be described in detail with reference to the accompanying drawings and embodiments.

[0045] This invention aims to maximize storage utilization. Utilizing the characteristic information of FC network data packets and considering the characteristics of the airborne environment and user application requirements, it adaptively modifies the dictionary-based compression algorithm, LZW. To reduce the time spent dynamically creating compilation tables in the traditional LZW algorithm and decrease time latency during compression, this invention separates and processes the fixed fields and payload of the data frame separately during compression. For example... Figure 1 As shown, a knowledge base is used for the compilation table of fixed fields in the data frame, while the LZW algorithm is used to dynamically construct the compilation table for the payload, thereby quickly achieving the compression task.

[0046] Step 1: Initialize the knowledge base L according to the relevant ICD definitions. Initialize the compilation table D, which contains all possible roots of the payload.

[0047] Step 2: Initialize the prefix I, suffix C, and the encoded stream S to be empty.

[0048] Step 3: After receiving the data frame, the monitoring buffer will segment the data frame into the fixed field H and the payload field P according to the format definition.

[0049] Step 4: Process the fixed field H. Segment the frame sequentially according to the format defined by the FC frame protocol. Segment field I, and search for the corresponding content in L based on the protocol field to which I belongs. Then, check if the specific content of I exists in the key-value pair corresponding to that protocol field. If it does, output the encoded value of I to S. Otherwise, add I to the key-value pair of the relevant protocol field.

[0050] Step 5: Determine if the encoding of H is complete. If the header encoding is complete, clear the string "I" and begin processing the compression of the payload "P". Otherwise, repeat step 3.

[0051] Step 6: Let character C be the next character in the data stream.

[0052] Step 7: Determine if I+C is in compilation table D. If yes, extend I with C, i.e., I = I+C. If not, output the encoding corresponding to the current prefix I in S. Then add I+C to compilation table D and set I = C;

[0053] Step 8: Determine if the encoding of P is complete. If complete, output the compressed string S; otherwise, return to step 5.

[0054] In step 1, the structure of the knowledge base L is defined as follows:

[0055]

[0056] The structure of compilation table D is defined as {root1: index number, root2: index number, ...}. Since network traffic is typically transmitted in hexadecimal format, during the initialization of compilation table D, 256 bytes from 0x00 to 0xff are filled into the table according to their indices. The index numbers are sequentially numbered starting from 1.

[0057] In step 2, the prefix I refers to the corresponding field in the current processing stream. The suffix C refers to the next character to be read. The encoded stream S refers to the output encoding, i.e., the data after compression.

[0058] In step 3, the data frame transmitted over the FC network mainly consists of an SOF delimiter, frame content, and an EOF delimiter. The frame content comprises the FC frame header, payload, and CRC. Generally, SOF and EOF each occupy 4 bytes, the FC frame header occupies 24 bytes, the CRC occupies 4 bytes, and the payload occupies 0 to 2^112 bytes. The SOF, EOF, and FC frame header have fixed protocol formats, and different fields represent different meanings; therefore, these parts are defined as fixed fields H. The CRC is used to verify the completeness of the frame header and payload fields. Like the payload fields, it has uncertainty, so it is categorized as a payload field P.

[0059] Specific implementation methods of this invention:

[0060] Suppose there is an FC data stream, and the hexadecimal representation of this frame is:

[0061] 0xBCB55656 04010003 0401000A 493A0018 (Frame Header)

[0062] 00000000013EFFFF0000000000052301 0000000000000000200001400000000

[0064] 00004DE7148F00000000000000000000 (Load)

[0065] BC6DCC62BC957575 (frame end).

[0066] The knowledge base L used is referenced in Table 1.

[0067] Table 1 (Common Knowledge Base Reference Values ​​for Protocol Fields)

[0068]

[0069]

[0070]

[0071]

[0072] Step 1: Initialize the knowledge base L according to the relevant ICD definitions. Initialize the compilation table D, which contains all possible roots of the payload. The initialized knowledge base L is:

[0073] {

[0074] "SOF":{"OxBCB55656":0x0,"0xBCB53636":0x1},

[0075] "EOF":{"0xBC95D5D5":0x0,"0xBC957575":0x1}

[0076] "R_CTL":{"0x22":0x0,"0x23":0x1,"0x24":0x2,"0x04":0x3},

[0077] "D_ID":{"0x10000":0x100,"0x10001":0x101,"0x10002":0x102,"0x100 03":0x103,"0x10004":0x104,"0x10005":0x105,"0x10006":0x106,"0x1 0007":0x107,"0x10008":0x108,"0x10009":0x109,"0x1000a":0x10a,"0 x1000b":0x10b,"0x1000c":0x10c,"0x1000d":0x10d,"0x1000e":0x10e},

[0078] "CS_CTL / Priority":{"0x0":0x0,"0x2":0x1,"0x4":0x2,"0x8":0x3},

[0079] "S_ID":{"0x10000":0x100,"0x10001":0x101,"0x10002":0x102,"0x10003":0x103,"0x10004":0x104,"0x10005":0x105,"0x10006":0x106,"0x10007":0x107,"0x10008":0x108,"0x10009":0x109,"0x1000a":0x10a,"0x1000b":0x10b,"0x1000c":0x10c,"0x1000d":0x10d,"0x1000e":0x10e},

[0080] "TYPE":{"0x01":0x0,"0x49":0x1},

[0081] "F_CTL":{"0x3A0018":0x0,"0x320018":0x1},

[0082] "SEQ_ID":{"0x00":0x00},

[0083] "DF_CTL":{"0x00":0x0},

[0084] "SEQ_CNT":{"0x00":0x00},

[0085] "OX_ID":{"0xFFFF:0xFFFF},

[0086] "RX_ID":{"0xFFFF:0x0},

[0087] "Parameter":{"0x00000000":0x0,"0x830":0x1,"0x1060":0x2},

[0088] "Message ID":{"0x15012":0x0,"0x15013":0x1,"0x52301":0x2},

[0089] "Reserved":{"0x0000000000000000":0x0},

[0090] "L+Prority":{"0x0":0x0,"0x1":0x1,"0x2":0x2,"0x4":0x3,"0x80":0x4,"0x81":0x5,"0x82":0x6,"0x84":0x7},

[0091] "Message Payload Length":{},

[0092] "LS_CMD":{"0xE0000000":0x0,"0xE1000000":0x1,"0xE4000000":0x2}

[0093] "FunctionID":{"0x2F00E008":0x0,"0x9200E00B":0x1}

[0094] }

[0095] Step 2: Initialize the prefix I, suffix C, and encoded stream S (compressed monitoring data) to be empty. Set I to empty, C to empty, and S to empty.

[0096] Step 3: After receiving a data frame, the monitoring buffer segments the data frame according to the format definition, extracting the fixed field H and the payload field P. The stream is then parsed, and the fixed field H is extracted. H includes the SOF, FC header, and EOF tail field. The SOF and FC headers include:

[0097] 0xBCB55656

[0098] 0x040100030401000A493A001800000000013EFFFF00000000

[0099] The protocol field is 0x49, which indicates the ASM protocol. Based on this, the ASM header information can be extracted as follows:

[0100] 0x00052301000000000000000002000014

[0101] The tail EOF includes: 0xBC957575

[0102] The extracted load P includes: 0x0000000000004DE7148F00000000000000000000 and BC6DCC62 (BC6DCC62 is CRC encoding).

[0103] Step 4: Process the fixed field H (using the initial knowledge base L). Segment H sequentially according to the FC frame protocol definition format. H is segmented into the set {0xBCB55656,0x04,0x010003,0x04,0x01000A,0x49,0x3A0018,0x00,0x00,0x0000,0x013E,0xFFFF,0x000000000005,0xBC957575} according to the format definition. Extract field I. Search for the corresponding content in L based on the protocol field to which I belongs. Then, check if the specific content of I is in the key-value pair corresponding to the protocol field. If yes, output the encoded value of I to S. Otherwise, add I to the key-value pair of the relevant protocol field. First, take 0xBCB55656 from the set and assign it to I. At this time, the protocol field to which I belongs is "SOF". In the knowledge base L, SOF involves two values, namely {"OxBCB55656":0x0,"0xBCB53636":0x1}. Therefore, the encoding of I is 0x0. Output this encoded value to S.

[0104] Step 5: Determine if the encoding of H is complete. If the header encoding is complete, clear the string I and begin processing the compression of the payload P. Otherwise, repeat step 3. If the encoding of H is not complete, return to step 4. I = 0x04 (process the second field 0x04 of the fixed field H), the corresponding protocol field is "R_CTL", query the knowledge base L, find the corresponding encoded value "0x3", and output it to S, S = 0x03. Repeat the above steps until I = 0xBC957575, the protocol corresponding to this field is "EOF", query the knowledge base L to retrieve the encoded value 0x1 and add it to S, S = 0x03103210a1000000013E002022141. At this point, the fixed field processing is complete, and P is initialized to empty.

[0105] Step 6: Set character C to the next character in the data stream (character C = the first character). Now begin processing the payload field. Set C to 0x00.

[0106] Step 7: Determine if I+C is in compiler table D. If I+C is 0x00 and is in compiler table D, then C is used to extend (I+C)I, i.e., I is 0x00 (I = I+C).

[0107] Step 8: Determine if the encoding of P is complete. If complete, output the compressed string S; otherwise, return to step 6. At this point, the encoding of P is not complete, so return to step 6. Let C be the next character 0x00, I+C = 0x0000, which is not in the compilation table D. If it is not in the compilation table D, output the encoding corresponding to the current prefix I to S. That is, output 0x00 to S. Then add I+C to the compilation table D and set I = C, so a new key-value pair {"0x0000":"0x100"} is added to D, at which point I = 0x00.

[0108] The encoding of P is not yet complete. C is the next character 0x00, I+C=0x0000. In the compilation table D, I is extended by C, I=0x000000. C takes the next character 0x00, I+C=0x000000, which is not in the compilation table D. The encoding corresponding to I is output to S, that is, S=S+0x100100. Then, a new key-value pair {"0x000000":"0x101"} is added to D, I=0x00.

[0109] If C is set to the next character 0x00, then I + C = 0x0000. In compiler table D, I is expanded with C, so I = 0x0000. If C is set to the next character 0x00 again, then I + C = 0x000000. In compiler table D, I is expanded with C, so I = 0x000000. If C is set to the next character 0x00, then I + C = 0x00000000, which is not in compiler table D, then the encoding of I is output to S, i.e., S = S + 0x100100101. Then, a new key-value pair {"0x00000000":"0x102"} is added to D, and I = 0x00.

[0110] Take C as the next character 0x4D. I+C=0x004D is not in the compilation table D. Output the code of I to S, that is, S=S+0x10010010100. Then add a new key-value pair {"0x004D":"0x103"} to D, and I=0x4D.

[0111] Take C as the next character 0xE7, I+C=0x4D7E is not in the compilation table D, output the code of I to S, S=S+0x100100101004D, and then add a new key-value pair {"0x4D7E":"0x104"} to D, I=0x7E.

[0112] Take C as the next character 0x14, I+C=0x7E14 is not in the compilation table D, output the encoding of I to S, S=S+0x100100101004D7E, then add a new key-value pair {"0x7E14":"0x105"} in D, I=0x14.

[0113] Take C as the next character 0x8F, I+C=0x148F is not in the compilation table D, output the encoding of I to S, S=S+0x100100101004D7E14, then add a new key-value pair {"0x148F":"0x106"} in D, I=0x8F.

[0114] Take C as the next character 0x00. I+C=0x8F00 is not in the compilation table D. Output the encoding of I to S, S=S+0x100100101004D7E148F. Then add a new key-value pair {"0x8F00":"0x107"} to D, and I=0x00.

[0115] If C is set to the next character 0x00, then I + C = 0x0000. In compiler table D, I is expanded with C, so I = 0x0000. If C is set to the next character 0x00 again, then I + C = 0x000000. In compiler table D, I is expanded with C, so I = 0x000000. If C is set to the next character 0x00 again, then I + C = 0x00000000. In compiler table D, I is expanded with C, so I = 0x00000000. Take C as the next character 0x00. I+C = 0x0000000000 is not in the compilation table D. Output the encoding of I to S, that is, S = S + 0x100100101004D7E148F102. Then add a new key-value pair {"0x0000000000":"0x108"} to D, and I = 0x00.

[0116] If C is set to the next character 0x00, then I + C = 0x0000. In compiler table D, I is expanded with C, so I = 0x0000. Continue setting C to the next character 0x00, then I + C = 0x000000. In compiler table D, I is expanded with C, so I = 0x000000. (This process is repeated four times in the original text.) Take C as the next character 0x00. I+C = 0x000000000000 is not in the compilation table D. Output the code of I to S, that is, S = S + 0x100100101004D7E148F102108. Then add a new key-value pair {"0x000000000000":"0x109"} to D, and I = 0x00.

[0117] Take C as the next character 0xBC, I+C=0x00BC is not in the compilation table D, output the encoding of I to S, S=S+0x100100101004D7E148F10210800, then add a new key-value pair {"0x00BC":"0x10a"} in D, I=0xBC.

[0118] Take C as the next character 0x6D, I+C=0xBC6D is not in the compilation table D, output the code of I to S, S=S+0x100100101004D7E148F10210800BC, then add a new key-value pair {"0xBC6D":"0x10b"} in D, I=0x6D.

[0119] Take C as the next character 0xCC, I+C=0x6DCC is not in the compilation table D, output the encoding of I to S, S=S+0x100100101004D7E148F10210800BC6D, then add a new key-value pair {"0x6DCC":"0x10c"} ​​in D, I=0xCC.

[0120] Take C as the next character 0x62, I+C=0xCC62 is not in the compilation table D, output the code of I to S, S=S+0x100100101004D7E148F10210800BC6DCC, then add a new key-value pair {"0xCC62":"0x10d"} in D, I=0x62.

[0121] Step 8: Determine if the encoding of P is complete. If complete, output the compressed string S. At this point, the encoding of the payload P part is finished. Output the encoding corresponding to I to S. The final S (compressed monitoring data) = 0x03103210a1000000013E002022141100100101004D7E148F10210800BC6DCC ​​62.

[0122] Beneficial effects of the embodiments of the present invention:

[0123] This paper improves upon the traditional LZW compression algorithm by utilizing the inherent characteristics of FC data packets and processing data frames separately according to their format definitions. In the FC protocol frame format definition, different bytes represent different meanings. An FC protocol frame typically consists of an SOF delimiter (frame header), frame content, and an EOF delimiter (frame trailer). The frame content comprises the FC frame header, payload, and a CRC field. In FC communication, except for the payload data and the CRC field, which are not fixed, other parts have strict content definitions, each with corresponding semantic representations. These contents are clearly defined in the ICD (Interface Control Definition), with low probability of randomness. To reduce the time spent dynamically creating the compilation table in the traditional LZW algorithm and reduce time delays during compression, the fixed fields of the data frame and the payload are processed separately during compression. A knowledge base dictionary is used for the compilation table in the data frame header, while the LZW algorithm is used to dynamically construct the compilation table for the payload, thereby achieving rapid compression.

[0124] The above description is merely a specific embodiment of the present invention and should not be construed as limiting the scope of the invention. Therefore, any substitution of equivalent components or equivalent changes and modifications made within the scope of protection of this patent should still fall within the scope of this patent. Furthermore, the technical features, technical features and technical solutions, and technical solutions in this invention can be freely combined and used.

Claims

1. A method for compressing monitoring data of an FC network switch, characterized in that, include: The monitoring data of the FC network switch is segmented into fixed fields. H and load P ; Initialize the knowledge base according to the format defined by the FC frame protocol. L Initialize the compilation table D The compilation table D Used to store the load P All roots in the knowledge base L Used to fix the field H The subfields in the code are converted to the set encoded values; According to the knowledge base L The fixed field H Compressed into a first compressed encoded stream, including: According to the protocol format definition of the FC frame, the fixed fields are... H The data is divided into multiple subfields; all subfields are processed in a loop until all subfields have been processed; the compressed codes generated by each subfield are concatenated to generate a first compressed encoded stream; according to the protocol format definition, the protocol field to which the subfield belongs is determined; in the knowledge base L In the process, based on the protocol fields, the field content that matches the subfield and the corresponding encoding value of the field content are queried. If the matching field content is found, the encoding value is output as the compressed encoding. According to the compilation table D The load P Compress into a second compressed encoded stream; The first compressed encoded stream and the second compressed encoded stream are concatenated to generate compressed monitoring data.

2. The method for compressing monitoring data of an FC network switch according to claim 1, characterized in that, Initialize the knowledge base according to the format defined by the FC frame protocol. L ,include: The monitoring data is divided into multiple protocol fields according to the format defined by the FC frame protocol. Each protocol field includes multiple sets of field explanations, and each set of field explanations includes the field content and the encoded value corresponding to the field content. After setting a corresponding encoding value for each of the field contents, the protocol field, the field content, and the encoding value are saved to the knowledge base. L middle.

3. The method for compressing monitoring data of an FC network switch according to claim 1, characterized in that, Initialize the compilation table D, including: Use the hexadecimal numbers from 0 to 255 as the initial root, and use the sequential number of the initial root as the index number; Save the initial root and the index corresponding to the initial root to the compilation table. D .

4. The method for compressing monitoring data of an FC network switch according to claim 1, characterized in that, Also includes: If no matching field content can be found, set the set encoding value corresponding to the current subfield; The protocol field, the subfield, and the set encoding value corresponding to the current subfield are respectively used as the knowledge base. L The protocol fields, field contents, and encoded values ​​are appended to the knowledge base. L middle 。 5. The method for compressing monitoring data of an FC network switch according to claim 1, characterized in that, According to the compilation table D The load P Compressed into a second compressed encoded stream, including: Read the load P The first character in the compilation table D The index number corresponding to the first character is obtained from the code, and the index number is used as the second compression code. Read the load in sequence P All characters following the first character, up to the payload. P All characters are converted to the second compression code, and all the second compression codes are concatenated in order to generate a second compression code stream: The character read is taken as the first character, and the character after the first character is taken as the second character; Concatenate the first character and the second character to form a middle character, and determine whether the middle character is in the compilation table. D middle; If the intermediate character is in the compilation table D In the compilation table D The index number corresponding to the intermediate character is obtained, and the index number is used as the second compression code.

6. The method for compressing monitoring data of an FC network switch according to claim 5, characterized in that, Also includes: If the intermediate character is not in the compilation table D In the process, the intermediate character is added as a new root to the compilation table. D In the middle, a new index number is assigned to the new root; The new index number is used as the second compression code.

Images