EP1588493A2 - Blockdatenkompressionssystem, bestehend aus einer kompressionseinrichtung und einer dekompressionseinrichtung, und verfahren zur schnellen blockdatenkompression mit multi-byte-suche - Google Patents
Blockdatenkompressionssystem, bestehend aus einer kompressionseinrichtung und einer dekompressionseinrichtung, und verfahren zur schnellen blockdatenkompression mit multi-byte-sucheInfo
- Publication number
- EP1588493A2 EP1588493A2 EP04702277A EP04702277A EP1588493A2 EP 1588493 A2 EP1588493 A2 EP 1588493A2 EP 04702277 A EP04702277 A EP 04702277A EP 04702277 A EP04702277 A EP 04702277A EP 1588493 A2 EP1588493 A2 EP 1588493A2
- Authority
- EP
- European Patent Office
- Prior art keywords
- node
- dictionary
- literal
- output
- unit
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Ceased
Links
- 238000000034 method Methods 0.000 title claims description 122
- 238000007906 compression Methods 0.000 title claims description 74
- 230000006835 compression Effects 0.000 title claims description 58
- 238000013144 data compression Methods 0.000 title claims description 45
- 230000006837 decompression Effects 0.000 title claims description 30
- 230000015654 memory Effects 0.000 claims description 190
- 230000008569 process Effects 0.000 claims description 44
- 239000000872 buffer Substances 0.000 claims description 22
- 238000012545 processing Methods 0.000 claims description 18
- 230000006870 function Effects 0.000 claims description 8
- 230000002829 reductive effect Effects 0.000 claims description 7
- 230000001960 triggered effect Effects 0.000 claims description 4
- 230000003139 buffering effect Effects 0.000 claims description 3
- 230000001186 cumulative effect Effects 0.000 claims description 3
- 230000003068 static effect Effects 0.000 claims description 3
- 238000006467 substitution reaction Methods 0.000 claims description 3
- 238000003780 insertion Methods 0.000 claims 1
- 230000037431 insertion Effects 0.000 claims 1
- 238000004422 calculation algorithm Methods 0.000 description 10
- 239000012634 fragment Substances 0.000 description 8
- 238000012546 transfer Methods 0.000 description 6
- 230000008901 benefit Effects 0.000 description 5
- 238000010586 diagram Methods 0.000 description 5
- 238000013461 design Methods 0.000 description 4
- 230000005540 biological transmission Effects 0.000 description 3
- 238000004364 calculation method Methods 0.000 description 3
- 230000036961 partial effect Effects 0.000 description 3
- 230000003044 adaptive effect Effects 0.000 description 2
- 238000013459 approach Methods 0.000 description 2
- 230000006399 behavior Effects 0.000 description 2
- 230000001419 dependent effect Effects 0.000 description 2
- 238000006073 displacement reaction Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 230000008520 organization Effects 0.000 description 2
- 230000002441 reversible effect Effects 0.000 description 2
- 238000012549 training Methods 0.000 description 2
- 101000836529 Brevibacillus brevis Alpha-acetolactate decarboxylase Proteins 0.000 description 1
- 102100027269 Fructose-bisphosphate aldolase C Human genes 0.000 description 1
- 238000004458 analytical method Methods 0.000 description 1
- 230000015572 biosynthetic process Effects 0.000 description 1
- 230000001427 coherent effect Effects 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 238000010276 construction Methods 0.000 description 1
- 230000003247 decreasing effect Effects 0.000 description 1
- XREKLQOUFWBSFH-UHFFFAOYSA-N dimethyl 2-acetylbutanedioate Chemical compound COC(=O)CC(C(C)=O)C(=O)OC XREKLQOUFWBSFH-UHFFFAOYSA-N 0.000 description 1
- 238000012804 iterative process Methods 0.000 description 1
- 238000007619 statistical method Methods 0.000 description 1
- 230000001360 synchronised effect Effects 0.000 description 1
- 230000009466 transformation Effects 0.000 description 1
- 238000000844 transformation Methods 0.000 description 1
- 230000007704 transition Effects 0.000 description 1
Classifications
-
- H—ELECTRICITY
- H03—ELECTRONIC CIRCUITRY
- H03M—CODING; DECODING; CODE CONVERSION IN GENERAL
- H03M7/00—Conversion of a code where information is represented by a given sequence or number of digits to a code where the same, similar or subset of information is represented by a different sequence or number of digits
- H03M7/30—Compression; Expansion; Suppression of unnecessary data, e.g. redundancy reduction
- H03M7/3084—Compression; Expansion; Suppression of unnecessary data, e.g. redundancy reduction using adaptive string matching, e.g. the Lempel-Ziv method
Definitions
- Block data compression system consisting of a compression device and a decompression device, and method for fast block data compression with multi-byte search
- the invention relates to a block data compression system, consisting of a compression device and a decompression device, and a method for fast block data compression with multi-byte search in the field of data compression, and in particular to a lossless, adaptive and reversible digital circuit arrangement for fast block data compression in memory and telecommunications equipment.
- Digital data compression is a well-known means of reducing the space required in mass storage devices. At the same time, data compression minimizes data transmission time in networks, satellite connections and similar applications. The ever increasing amounts of information that are processed, transmitted and stored by modern systems represent a challenge for modern applications, so that data compression is correspondingly important.
- the next generation of Huffmann codes was aimed at converting it into a one-step algorithm and adapting it to context changes.
- the algorithm was thus able to take into account the probability of occurrence of the symbols already processed for the encoding of the next arriving symbol (cf. DE Knuth, "Dynamic Huffman codes”; Journal of Algorithms, Vol. 6, No. 2; June 1985; pp. 163-180; JS Vittier; "Design and analysis of dynamic Huffman codes”; Journal of the ACM; Vol. 34; No. 4; October 1987; pp. 825-845; and JS Vittier, "Dynamic Huffman coding "; ACM Transaction on Mathematical Software; Vol. 15; No. 2; June 1989; pp. 158-167).
- the main feature of this algorithm consists of a window that is moved along the uncompressed input data. At each step it is examined whether the incoming substring matches any string within the window. The goal is to determine the longest identical string. As a result of the search, a pair ⁇ position, length> is determined which uniquely describes this input character string with regard to the match with the corresponding character string in the window. This pair is then encoded and fed to the encoded data stream. The window is then moved further so that it contains the matching partial character string, the oldest characters possibly falling out of the window in order to keep the length of the window constant.
- the incoming character or the incoming characters are shown in their original form - also referred to as "literal" - in the output data stream. Both cases are marked appropriately to enable decoding.
- a dynamic dictionary is constructed (hence the name "Dynamic Dictionary Method"), which contains substrings of variable length. If a match is found between an incoming substring and a dictionary element, this string is replaced by the address of the corresponding element in the dictionary.
- the dictionary also contains all the individual characters of the input alphabet in the lower address area. Individual characters in the input data stream that are not part of the character strings contained in the dictionary (at least 2 characters) are therefore represented by the addresses of the individual characters in the dictionary and transmitted to the output.
- the pair ⁇ ZK, next character> is searched again until a mismatch is found, i.e. the string currently searched for does not exist in the dictionary.
- the address of the last matching dictionary entry is inserted into the output data stream and the mismatching pair ⁇ substring, last character> is added to the dictionary at a new address, ie ZLW can only expand dictionary entries by one character per coding step. Then the processing of the input character string is continued with the last, mismatched character.
- the object of the invention is to develop a block data compression system consisting of a compression device and a decompression device, and a method for fast block data compression with multi-byte search for optimal coding during the learning phase of substitutive methods, in which parts are limited in length and relatively small the input file can be compressed independently of one another, as is required for direct access storage devices or telecommunication devices, and which allow high performance through a number of accelerating architecture structures and data flow principles, for example high-grade pipelining.
- a block data compression system consisting of a compression device and a decompression device, the compression device containing an input FIFO to buffer input symbols according to the first-in-first-out principle, and this input FIFO with a control component, one Modeling unit is connected, this modeling unit being connected to a Trie dictionary memory, a zero finder lookup table, search components in the form of a comparison unit, memory components in the form of a literal dictionary and a coding unit.
- the coding unit is in turn connected to an output FIFO via an alignment unit.
- the Trie dictionary memory consists of a large number of memory locations, which the modeling unit accesses in parallel and forms the higher-order dictionary, which is addressed by a hash function which calculates from the first characters contained in the input FIFO becomes.
- the zero finder lookup table is used to predetermine unused space in the higher-order dictionary, the modeling unit accessing the higher-order dictionary in order to determine whether the character string contained in the input FIFO is by any internal or external node that is in this Dictionary exists, can be replaced.
- the comparison unit carries out the parallel comparison of several characters in order to determine the maximum length of the match between the relevant node in this dictionary and the character string in the input FIFO.
- the literal dictionary forms the low-order dictionary, the content of the literal dictionary being used to generate the coded form for character strings of length 1 in the modeling unit.
- the modeling unit determines whether the result of the parallel search in the comparison unit or the content of the literal dictionary is selected as the output variable of the modeling unit.
- the modeling unit performs an iterative parallel search when one or more nodes contained in the Trie dictionary memory increase the length of the match with the character string in the input FIFO, as well as pipelining the results to the coding unit, which generates compact, variable-length output code words that produce a relative representation of the output values of the modeling unit is used, the output code words being dependent on the current state of the coding unit.
- the coding unit contains components for pipelining this output code word of variable length to the alignment unit, which converts the output code word of variable length into a code word aligned with byte boundaries.
- the output FIFO contains components for temporary Storage of these code words aligned on byte boundaries until the specified width of the output bus is reached and a suitable output time is available, in order in this way to convert a block of uncompressed digital input data with the aid of the compression process into a compressed data stream for output via the output bus of the output FIFO.
- the modeling unit contains update components for inserting both the provisional and the final information into the higher-order dictionary, which cause the current character string at the output of the input FIFO to show the current status of the Trie dictionary memory, which is the dictionary higher Contains order influences, the preliminary information accelerates the compression process in the event that the final update is identical to the preliminary update and consequently this final update is avoided.
- the modeling unit may contain components for updating the literal dictionary in parallel, this being effected by a single character at the output of the input FIFOS and taking place when the literal dictionary is unable to carry out a previous one Find coding for the character at the output of the input FIFO, and the Trie dictionary memory does not find an internal node NODE that matches the multi-character string currently contained in the input FIFO.
- it can also contain components for parallel updating of the prefix of the code word used by the coding unit, this prefix being updated by the coding unit on the basis of the internal status of the modeling unit and based on the number of different code words which were transmitted by the modeling unit to the coding unit ,
- both the modeling unit and the coding unit have update components which carry out the highly compact coding of output code words and are present in the modeling unit in the form of memory components which point to the last preceding internal node NODE, which is in the dictionary dictionary was used, and that the output code word which was transmitted to the coding unit is formed as the difference between the last previous internal node NODE and the current node to be transmitted.
- the modeling unit, the coding unit, the alignment unit and the output FIFO can also contain components for coordinating parallel operation with different and independent code words and thus form a pipeline, starting with the modeling unit, these components consisting of memories in the modeling unit, the coding unit , the alignment unit and the output FIFO, which contain the code word from the output of the previous block and which result from the processing of this code word within the respective unit resultant modified code word during the next pipeline step to the next unit in the compression chain.
- This pipeline is organized in such a way that a standstill for the modeling unit is largely avoided during the compression process.
- the decompression unit for decompressing digital data blocks contains components for buffering input code words according to the first-in-first-out method as part of the overall data compression system, these input code words encoding different lengths for the original, uncompressed Represent symbols of fixed length.
- the Trie dictionary memory and the literal dictionary are connected to a modeling unit which has components for interacting with the Trie dictionary memory, which consists of more than one memory position, which in turn has an output FIFO, an interface unit, an input FIFO, an alignment unit with a decoding unit and the other with a block buffer and directly connected to the decoding unit.
- the alignment unit which converts information supplied by the input FIFO and aligned at byte boundaries into a code word representation of variable length, generates a byte-organized data format for the decoding unit, whereby it contains components for receiving code words of variable length and additionally components for determining the correct length of the prefix , the node number, the node type and the relative match length with the existing node in the Trie dictionary memory, which is described by the code word, or vice versa contains the correct bit length of the prefix and the relative number of the single symbol in the literal dictionary.
- the decoding unit contains components for interacting with the modeling unit and, based on the content of the internal registers of the modeling unit, the current state of the Trie dictionary memory and the code word, determines the correct node number and the position of the first symbol and the absolute match length, if the code word is of the node type.
- the modeling unit is also connected in parallel with the literal dictionary.
- connection is necessary in order to transfer the code substitution defined by the literal dictionary if the codeword is of the literal type and contains a component for executing a multibyte copy operation, which either contains a symbol that occurred earlier or a character string from the one determined
- the position in the block buffer or output FIFO is copied to the current position in the output FIFO, the output FIFO containing components for the temporary storage of these code words aligned on byte boundaries until the specified width of the output bus is reached and a suitable point in time is available for the results the decompression to the output unit via the interface unit.
- the modeling unit has update components which insert both provisional and final nodes in the Trie dictionary memory, the nodes causing the current character string in the output memory or the corresponding FIFO, which is identified by a position field, to show the current status of the Trie dictionary memory affected, and wherein the preliminary information, which was previously written into the Trie dictionary memory by the modeling unit, the Processing speeded up in the event that the final update is identical to the preliminary one and consequently the final update is avoided.
- Has update components for a parallel update of the literal dictionary which is triggered by a single character addressed via the corresponding input FIFO, the update process taking place when the modeling unit determines that no internal node in the dictionary dictionary is used by the current code word which is supplied by the decoding unit.
- the modeling unit has update components for a parallel update of the prefix of the code word used by the decoding unit, the prefix, which was updated by the decoding unit on the basis of the internal status of the modeling unit and the number of different code words, by the modeling unit is transmitted to the decoding unit, the decoding unit using a self-balancing prefix tree and this tree assigning the shortest prefix to the most frequently used type of code words.
- the input FIFO, the alignment unit, the decoding unit, the modeling unit and the output FIFO may contain components for coordinating the parallel operation with different and independent code words and thus pipelining, starting with the alignment unit, is carried out, these components consisting of memories in the modeling unit, the decoding unit, the alignment unit and the output FIFO, which store the code word from the output of the previous block for the next processing step.
- the pipeline is organized in such a way that the modified code word resulting from the processing of the current code word within the respective unit is transmitted to the next unit in the compression chain during the next pipeline step. This organization of the pipeline chain avoids a downtime for the modeling unit during the decompression process.
- the method for converting a block of input symbols into encrypted output code words of variable length in a data block compression system is achieved according to the invention in that the input symbols are transferred to an input FIFO, that on the basis of the first two symbols at the output of the input FIFO Hash address is calculated, which is used to search in parallel in the Trie dictionary memory and in the zero finder lookup table in order to quickly determine whether an internal node or a leaf node exists in the Trie dictionary memory. If the search in the Trie dictionary memory finds an internal node that matches the character string in the input FIFO in more than one character, the multi-byte search is continued iteratively until the longest match of the input character string in the input FIFO with existing nodes of the Trie dictionary memory is found.
- the node number is encoded in a relative form with respect to the last node formed and the code word is identified either as an internal node or as a leaf node in the dictionary dictionary.
- the match length transmitted to the coding unit is calculated in a differential form with respect to the last node passed through during the search. If the search in the dictionary dictionary does not find an internal node that matches the character string in the input FIFO in more than one character, the literal dictionary determines whether the code word is represented by a known literal and thus by the variable-length code that was assigned to the sign when it appeared earlier. Otherwise, the character is identified as a new literal and is displayed in its original form if it is not yet in the literal dictionary.
- a prefix of variable length is assigned to each code word type in accordance with the type of code word used, this prefix being determined via a self-balancing prefix tree on the basis of the cumulative, current count values for the different code word types.
- the resulting variable-length code word is converted via an alignment operation into an output result aligned with byte boundaries, the aligned output code words in the output FIFO are stored and combined there in groups in order to carry out an efficient write operation on the final storage medium with regard to time and bus width can. In this way, a compressed representation in the form of a block of output code words is generated from an uncompressed block of input symbols.
- a data structure is created in the Trie dictionary memory, in which internal nodes and leaf nodes exist side by side in the same dictionary. The leaf nodes start at 1 and are counted up, the internal nodes start with the highest number and are counted down, whereby both types of nodes do not collide with each other. If the search in the Trie dictionary memory finds an internal node that matches the character string in the input FIFO in more than one character, but does not match the exact length of each node in the search path, this dictionary is created by creating a new internal Updated node.
- the count for the number of internal nodes is reduced by 1 and a new leaf node is formed.
- This new leaf node is assigned the value of the maximum length of this character string as the depth and the end node counter is then increased by 1. If the search in the Trie dictionary memory finds an internal node that matches the character string in the input FIFO in more than one character and at the same time matches the exact length of a node in the search path, steps are carried out to update the node reached, the node reached in this way receiving the current position pointer in the input data memory in its position field.
- This method is also carried out if the internal node is not a leaf node and in this case steps are taken to generate a new leaf node, this new leaf node in receives the current position pointer in the input data memory in its position field, the end node counter then being counted up. If the search in the higher-order Trie dictionary memory does not find an internal node that matches the character string in the input FIFO in more than one character, a new leaf node is created in this dictionary, and this new leaf node is given the maximum length. Finally, the end node counter is incremented.
- the method is also carried out if the input character at the output of the input FIFO is not contained in the literal dictionary, the method including the steps for updating the literal dictionary, in that the number corresponding to the input symbol corresponds to the number of entries previously in new symbols received in this block are assigned. Finally, the counter for the known symbols is increased by one.
- One embodiment of the method provides that, in order to decode the original data block from a coded block of code words, the code words aligned in bytes are entered in the input FIFO, so that the input FIFO converts these byte-aligned code words of fixed length back into such variable lengths and as Provides input variable for the decoding step by assigning these code words to a new literal, a known literal, an internal node or a leaf node on the basis of the dynamic prefix contained in the relevant code word.
- This procedure is carried out if the code word is recognized as a new literal and there is a single symbol in the code word that is fed directly to the output FIFO, or if the code word is recognized as a known literal and a single symbol from the code word via the literal Dictionary is translated back and passed to the output FIFO, or if the code word is of the type either an internal node or a leaf node in the Trie dictionary memory.
- the method reads from the Trie dictionary memory the parent node of the relevant internal node in order to determine the previous block position at which a similar character string exists in the output FIFO as well as the node depth which is returned to the decoder which contains the number of characters for the display the relative length required bits and the actual relative value itself calculated.
- the calculation is carried out by adding this relative length to the aforementioned parent node of the internal node, and in this way determining the parameters for the execution of the copying step (s) taking place for several characters.
- This copying process contains all the steps to copy as many symbols from the position described by the position field of this decoded internal node into the output FIFO as is determined by the aforementioned absolute length of the copy. All these steps are repeated until no further code words have to be decoded and the original symbol block is thus restored from the compressed block of code words.
- the Trie Dictionary memory updated by forming a new leaf node, this new leaf node receiving the current position pointer in its input field in its position field. Finally, the end node counter is incremented. A new internal node is formed, this new internal node receiving the current position pointer in the output FIFO in its position field. The depth of this new internal node is assigned the absolute match length of the character string, which was calculated in the decoding process. Finally, the counter for the number of internal nodes is counted down by one.
- the Trie-dictionary memory becomes Creation of a new leaf node updated, this new leaf node receiving the current position pointer in its position field in the output FIFO. Finally, the end node counter is incremented.
- the prefixes of the code word types can be updated both during compression and during decompression.
- the prefixes can be updated as soon as any of the counters belonging to the elements of the pairs [known literal, leaf node] and [new literal, internal node] becomes larger than the count of the other element of the pair and this larger element is now the shorter one for the pair available coding and now compares this element with the largest element of the other pair and in turn assigns the shorter coding to the largest element, whereby the prefix tree balances itself to assign the shorter prefix to the more common code word type.
- the block data compression system contains two dictionaries.
- the first is a prefix-free Trie dictionary memory, which contains internal nodes NODE and leaf nodes LEAF.
- the second dictionary is a literal dictionary that processes the individual symbols that were not encoded by using the first dictionary.
- a search is carried out in a "zero finder look-up table" in order to determine whether the current partial character string in the local input FIFO matches one of the existing branches of the Trie dictionary memory. Then, if a match is found through multi-byte reading and speculative updating, the branch is traced down. This is done using a parallel multi-byte comparison module.
- all the internal nodes NODE matching the character string are examined down to the leaf that corresponds to the maximum number of characters allowed for determining the match.
- the result that is provided by the literal dictionary is transmitted.
- This can be the literal itself, provided that it is not yet contained in the literal dictionary, or the code supplied by this literal dictionary if it was previously detected within the block. In this way the encryption of data streams with a reduced alphabet is optimized.
- the code word New Literal NLIT contains characters that do not appear in the previous data stream
- the Codeword Known Literal KLIT contains characters that have already occurred in the previous input data stream, but do not produce any matches within the branches of the Trie dictionary memory that contains internal nodes NODE a reference to the matching substrings that end at an internal branch node of the Trie dictionary memory and the leaf node LEAF contains a reference to the matching substrings that end at a leaf node of a branch of the Trie dictionary memory.
- code words are then provided with a variable prefix using a self-balancing prefix tree. Codewords with the most frequent occurrence receive the higher priority, so that a higher agreement with the learning process of substitutive methods is achieved. At the same time, smaller code words are achieved during the first phases of compression.
- the method generally provides better adaptability to different data types for the limited size of the block compression.
- the coding unit of the data compression device works according to the pipeline principle and is active when the modeling unit has its Dictionaries finally updated. The coding unit almost optimally transforms the dictionary information obtained by using relative, variable code representations which result from the current status of the dictionaries. A code word of variable length is generated at the output.
- the alignment unit of the compression device is also structured according to a pipeline and works in parallel to the modeling and coding unit. It uses a high-speed method to align the variable-length code words supplied by the encoder with the byte boundaries required for the final output.
- the final results of the compression are temporarily stored in a first-in-first-out (FIFO) memory, which allows data transfer to the external memory corresponding to the connected bus and minimizes the peak bandwidth required by the arrangement.
- FIFO first-in-first-out
- 1 is a block diagram of a compression unit
- Fig. 3 shows a self-balancing prefix tree for the allocation of
- Fig. 4 is a block diagram of a decompression unit.
- Fig. 5 shows an embodiment of the compression method for a
- the invention relates to a block data compression system and a method for fast block data compression with multi-byte search.
- the device and the preferred implementation of the invention is shown in the block diagram, FIG. 1.
- FIG. 1 also shows the means for realizing the invention, which is possible through any hardware implementations, from the discrete IC application, FPGA technologies and all digital design technologies based on ASICs.
- a compression unit 1 consists of a Trie dictionary memory 4, which contains a higher-order dictionary, and a literal dictionary 2.
- the compression unit 1 can in principle be separated from the Trie dictionary memory 4. In the solution according to the invention, however, these are combined into a single solution. This will take advantage of using a direct memory interface 103 used for immediate access to long memory records.
- the Trie dictionary memory 4 is accessed via the memory interface 103, via which all electrical and timing-specific signals of the Trie dictionary memory 4 are transmitted.
- the Trie dictionary memory 4 is implemented as RAM in the comprehensive embodiment of the present invention, ROM solutions can also be used in special implementations. In this case, the ROM dictionaries must be created and preprogrammed in advance.
- Each entry in the dictionary dictionary 4 is organized in the form of a long data record.
- Each record contains the following fields: Father 210 (12-bits), position 211 (12-bits), counter value 212 (8-bits), new 213 (8-bits), node 214 (12-bits).
- the number of bits per field used in the preferred embodiment, which apply to the maximum internal block size of 4 kbytes, is given in parentheses as an example. The number of bits required changes in proportion to the increase or decrease in the block size.
- Trie dictionary memory 4 contains both internal nodes NODE and leaf nodes LEAF at the same time.
- the internal nodes NODE are counted incrementally from 1, while the nodes of the leaf node type LEAF are counted decremented from the maximum value (OxOfff for a block size of 4 kByte).
- the design rules that are used when creating and updating the dictionary dictionary 4 prevent any collision between these two types of nodes. At the same time, this design has significant advantages in terms of memory requirements compared to previous solutions.
- Each data record that is contained in the Trie dictionary memory 4 has a description for the stored fields, which looks as follows, shown in FIG. 2:
- the field position 211 contains the address of the starting point of the character string, which is described by the node, in the original input block.
- the field father 210 designates either the previous node of a specific node of the Trie dictionary memory 4 in the top-down search, if this exists, or the first symbol of the substring that this specific node represents (for example 'a' for character string ' abcd '). The distinction is made via a flag in the most significant bit.
- the New field 213 contains the symbol that indicates the path from the parent node to the specific node (e.g., NEW-c 'for the transition from the node representing' ab 'to the node representing' abc ').
- the counter value field 212 indicates the depth of match of the symbol strings that generate the respective node.
- the node 214 field specifies the number of the node within the dictionary dictionary 4.
- the content of the I / O memory bus 113 is read into the input FIFO 8, which in the preferred embodiment is capable of storing at least 64 bytes.
- the input FIFO 8 is used to generate a hash function which, as a result, generates an address for both the zero finder lookup table 3 and the trie dictionary memory 4. This address is used to determine whether a node exists in the dictionary dictionary 4, which could represent a character string with start symbols similar to the character string currently being analyzed.
- the modeling unit 6 executes a read / write operation on the specific hash Function calculated address started by means of the memory interface 103.
- the hash validity is confirmed, at the same time the node number stored in the node 214 field and all related information are read.
- This read information contains information regarding the previous occurrence of the last stored symbol chain, which contains the same initial pair of symbols, and the depth of the previously found match (in field counter value 212).
- a read / compare cycle is started.
- the comparison unit 5 is loaded via the FIFO comparison bus 108 with the symbols that follow the tested pair in the input FIFO 8. These are compared with the data read from the block buffer 10 via the buffer comparison bus 109, the transmission starting from the address derived from the content of the position field 211.
- 4 bytes are compared in the comparison unit 5 at the same time, so that by repeating the comparison operation and transmitting the results via the result comparison bus 104 to the modeling unit 6, matching character strings can be determined in a short time.
- This comparison is carried out until a mismatch is found or the comparison depth defined in the counter value 212 field is reached.
- the modeling unit 6 contains the maximum match length of the current symbol character string in the upper area of the input FIFO block 8 with the existing dictionary entries.
- the modeling unit 6 now sends a pair [relative node, relative displacement] to the coding unit 7.
- the “relative node” is derived from the difference between the last node determined in the dictionary and that determined by the field node 214.
- the relative shift is calculated as the difference between the current match depth and the depth of the parent node.
- the modeling unit 6 If, during the procedure described above, no match is found between either the father 210 field or the new field 213 of the examined node with the current register values (“hash check”), the modeling unit 6 generates a new hash address, repeated with this address the search in the Trie dictionary memory 4 or ends. The content of the zero finder lookup is used to determine the new hash address mentioned. Table 3.
- a literal coding type is used .
- the first character is then used to address the literal dictionary 2 via the literal bus 101, it being recognized from the data read back via the literal bus 101 whether the first symbol in the input FIFO 8 is already in the previously processed data stream happened. If the answer from the literal dictionary 2 is positive (identified by a one in the most significant bit of the answer), the literal coding which was assigned to the relevant symbol when it first appeared is received simultaneously via the literal bus 101.
- Assigning a variable number of bits for the literal coding of the individual characters shortens their coding in comparison to the case in which they are transmitted to the output in their original form. The number of bits is proportional to the alphabet size of the encoded data stream.
- the first two types of coding correspond to single-character coding, while the last two types correspond to multi-character coding, expressed by the content of the Trie dictionary memory 4. Since the number of units generated by the modeling unit 6 is greater than in all previous solutions, traditional marking methods are useless. Special measures must also be taken to keep the prefix length optimal.
- FIG. 3 shows the self-balancing prefix tree that is used for the dynamic prefix structure.
- the prefixes are divided into two groups (I and II), the node group I (302) including the NLIT coding in the NLIT node counter 304 and the LEAF coding in the LEAF node counter 305 and the node group II (303 ) the KLIT coding in the KLIT node counter 306 and the NODE coding in the NODE node counter 307.
- Each coding type has an up counter, all counters being set to zero at the start of the compression of the data block.
- FIG. 3a additionally shows a predefined start coding for each coding type, NLIT having the shortest code (1 bit) [0], followed by KLIT (2 bits) [10] as well as LEAF and NODE with 3 bits each [110 and 111].
- the corresponding prefix is selected from the tree for marking this code word for each code type newly coded and transmitted to the coding unit.
- the tree is then updated.
- the corresponding counter is increased and the counter reading is compared with the other counter in the group. As soon as the counter readings in the LEAF node counter 305 or in the NODE node counter 307 in FIG.
- each code type is assigned a quadrant within a clockwise priority circle 308. Because at the beginning of a data block, the probability of finding a new NLIT literal is far higher than the probability of finding any other code type (for the first symbol 100%), NLIT gets the shortest prefix and becomes the quadrant with the highest priority assigned. As soon as the alphabet begins to repeat at the input (however, the symbol pairs of the Trie dictionary memory 4 do not yet occur), the code types move clockwise, i.e. KLIT is now in the quadrant with the highest value.
- the Trie dictionary memory 4 is filling up more and more.
- the circle rotates again, whereby the occurrence of a leaf node LEAF as the next code word is assigned the highest significance.
- the dictionary memory 4 as soon as the data is sufficiently homogeneous, is able to express most of the input data using the internal node NODE due to the homogeneity of the data.
- the corresponding prefix now receives the shortest number of bits.
- FIG. 3b is only for illustration; The real behavior of the system from FIG. 3a differs to some extent from the behavior described above. However, it is helpful for a better understanding of the underlying process.
- the advantage of this method over previous solutions is that relatively high compression rates can be achieved for very small blocks or for the beginning of larger data blocks.
- the compression process has previously been explained on the premise of previously filled dictionaries, the description now focuses on the dictionary update process that takes place in the case of a self-adapting, dynamic process using the read-write memory, as is the case in the preferred embodiment is.
- the Trie dictionary memory 4 is updated as part of the compression steps by the modeling unit 6 in order to take into account the changes which were caused by the processed character or the processed character string.
- a new leaf node LEAF is created in each case. This represents the specific character string that begins with the characters at the output of input FIFO 8. The leaf node counter is then decreased by one.
- the parent node of this new leaf is the original symbol itself.
- the field is given Father 210 of the sheet to be newly generated the node number of the node in the Trie dictionary memory 4 which was last accessed. If, in addition, the target node depth is not reached during the search process during the step-by-step tracking of a branch of the dictionary dictionary 4, a new internal node is generated which characterizes the common part of at least two existing character strings in the dictionary dictionary memory 4.
- the new leaf node LEAF is created as a branch that begins in the internal node NODE that has just been created.
- this invention is capable of performing the update in the dictionary dictionary 4 simultaneously with the read-write cycle to the address of the last hash candidate by the Modeling unit 6 is calculated. Since the first write can take place before the modeling unit 6 has final knowledge of the length of the match, the node currently being accessed is updated in its field position 211 and a preliminary sheet is created in advance. This speed-increasing process is called speculative advance update (ASU). This preliminary leaf is generated on the assumption that the search in the Trie dictionary memory 4 remains unsuccessful and that the single current character addressed by the father 210 field will be the parent node of the leaf in question.
- ASU speculative advance update
- a similar speculative technique is used in parallel to the process described above for updating the literal dictionary 2. If a new literal NLIT is found as a result of a read operation in the zero finder lookup table 3 in FIG. 1, a speculative update of the literal dictionary 2 is carried out by writing the newly assigned index for the relevant input symbol.
- the modeling unit 6 Once the modeling unit 6 is processing a particular substring in the character input stream has completed, it transmits the code words via the input bus of the coding unit 105 to the coding unit 7 in FIG. 1.
- the task of the coding unit 7 is to convert this information into a bit stream which can later be understood by the decompression unit, with references to the current one Contents of all dictionaries and counters (sheet counters, node counters, 7), which are used for the compression process, are included insofar as they also have to be generated synchronously by the decoding unit.
- Bit operations performed by the coding unit 7 are predominantly direct logical transformations, so that no iterations are required, as a result of which the speed requirements of the compression method are met.
- the coding unit 7 applies the following rules, for the implementation of which the corresponding hardware implementations are available in the device:
- the leaf number is expressed relative to the current leaf counter using a triple prefix scheme (short, medium, long), whereby the number of bits for each digit can increase according to the leaf counter the number of bits required to represent the difference between the start sheet and the current sheet).
- the length of the symbol or dictionary match is also not expressed in absolute form, but by reference to the parent node of this leaf node. Unary coding, which favors particularly short codes, is used for these integers.
- node number is first reduced to the maximum number of bits specified by log 2 (node counter) and finally modified if within this coding space (determined by the bit length) not all coding options are used ("sparse codes").
- log 2 node counter
- bit length not all coding options are used
- the coding of variable length is transmitted via the input bus of the alignment unit 107 to the alignment unit 9 in FIG. 1, while the coding unit 7 releases itself for the next coding cycle generated by the modeling unit 6, which cycle runs parallel to the previous cycles or the previous cycle ran, and the next characters in the input FIFO 8 processed.
- the function of the alignment unit 9 is the chains convert encoded bits to a byte bound form that can be processed by the output FIFO 12.
- the alignment unit 9 contains a device for appending the new bit-coded data stream, which has been coded for the special code word, to the remaining part of the previous bit stream.
- the bit representations are concatenated.
- a further device for fast parallel shifting of the new bit stream by a certain number of bits is included. As a result of this operation, a different number of aligned bytes and a bit remainder are obtained for processing in the next alignment cycle.
- output bytes are then transferred via the output FIFO bus 111 to the output FIFO 12, in which they are buffered until the output bus width is reached. Then a request (typically a DMAS request) is generated for the output FIFO 114 output bus. In this way, the overall bandwidth of the system in which the data compression unit is located is optimized.
- a request typically a DMAS request
- additional memory space is provided for storing the different contexts in the Trie dictionary memory 4 via the memory interface 103. It also contains an upload / download device to / from this memory for transferring the register contents of all internal units and for the contents of all internal dictionaries.
- the encrypted data is transferred to the input FIFO 410 via the input bus of the alignment unit 508. This now works in reverse mode and only reads as many bytes as are necessary to keep it filled.
- the data contained in the input FIFO 410 is then transmitted to the alignment unit 407, in which the correct bit meaning and bit sequence of the represented code words of variable length are restored. This is done in close cooperation with the decoding unit 405, which takes over all tasks that are connected with the determination of the length of all data fragments that are contained in the specific code word. This is done with the help of the current contents of the registers, by the decoding unit 405 and the modeling unit 404 can be shared.
- the decoding unit 405 then checks the status of the self-balancing prefix tree in FIG. 3a in order to determine which code word type is to be decoded and for this purpose acquires information about the number and type of the code word fragments contained in it. When the decoding unit 405 has decrypted these fragments, the absolute values of the first fragment following the code word prefix are restored. This fragment can either represent a node in the Trie dictionary memory 4 (contained in the Trie dictionary memory 403) which must be restored symmetrically by the decoder, or it represents a literal code word which may use the symmetrical literal dictionary 402.
- the decoding unit 405 processes the information about the node depth of the specific node, which is supplied via the output bus of the decoding unit 504 from the modeling unit 404, and the displacement, which is obtained from the code word which comes from the alignment unit 407 via the bus 505 to maintain the absolute depth in the branch. It is a measure of the length of the matching string.
- This depth in the Trie dictionary memory 403 is transferred back to the modeling unit 404 via the bus 504.
- Modeling unit 404 then performs a multi-byte copy operation (starting at the position in the character string identified by the node of the Trie dictionary memory 403) from block buffer 408 to output FIFO 406.
- the output FIFO 406 assumes the task of stringing the output symbols for a write operation into the external I / O memory according to the bus width, initializing and executing the write operation.
- a DMA handshake protocol is normally used for this in order to obtain an optimal timing intensity / all for minimizing the bandwidth which is required for this external memory.
- the block data compression system consisting of a compression device and a decompression device, is shown again.
- the compression device contains an input FIFO 8 in order to buffer input symbols according to the first-in-first-out principle.
- This input FIFO 8 is connected to a control component and a modeling unit 6, this modeling unit 6 being connected to a drive Dictionary memory 4, a zero finder lookup table 3, search components in the form of a comparison unit 5, memory components in the form of a literal dictionary 2 and a coding unit 7 are connected.
- the coding unit 7 is in turn connected to an output FIFO 12 via an alignment unit 9.
- the Trie dictionary memory 4 consists of a plurality of memory locations, which the modeling unit 6 accesses in parallel and forms the higher-order dictionary, which is addressed by a hash function, which consists of the first characters contained in the input FIFO 8 are calculated.
- the zero finder lookup table 3 serves for the predetermination of unused space in the higher-order dictionary, the modeling unit 6 accessing the higher-order dictionary in order to determine whether the character string contained in the input FIFO 8 is by any internal or external node, that exists in this dictionary can be replaced.
- the comparison unit 5 carries out the parallel comparison of several characters in order to determine the maximum length of the match between the relevant node in this dictionary and the character string in the input FIFO 8.
- the literal dictionary 2 forms the low-order dictionary, the content of the literal dictionary 2 being used to generate the coded form for character strings of length 1 in the modeling unit 6.
- the modeling unit 6 determines whether the result of the parallel search in the comparison unit 5 or the content of the literal dictionary 2 is selected as the output variable of the modeling unit 6.
- the modeling unit 6 carries out both an iterative parallel search when one or more nodes contained in the Trie dictionary memory 4 increase the length of correspondence with the character string located in the input FIFO 8, and a pipelining of the results to the coding unit 7, the compact output code words of variable length generated, which uses a relative representation of the output values of the modeling unit 6, the output code words being dependent on the current state of the coding unit 7.
- the coding unit 7 contains components for pipelining this output code word of variable length to the alignment unit 9, which converts the output code word of variable length into a code word aligned with byte boundaries.
- the output FIFO 12 contains components for temporarily storing these code words aligned at byte boundaries until the specified width of the output bus is reached and a suitable output time is available, in order in this way to use the compression process to block a block of uncompressed digital input data into a compressed data stream for output via the output bus 114 of the output FIFO 12.
- the modeling unit 6 contains update components for inserting both the provisional and the final information into the higher-order dictionary, which cause the current character string at the output of the input FIFO 8 to show the current status of the Trie dictionary memory 4, which contains the higher order dictionary, the preliminary information accelerating the compression process in the event that the final update is identical to the preliminary update and consequently this final update is avoided.
- the modeling unit 6 may contain components for updating the literal dictionary 2 in parallel, these of a single character at the output of the input FIFO 8 and then takes place when the literal dictionary 2 is unable to find a previous coding for the character at the output of the input FIFO 8, and the Trie dictionary memory 4 does not find an internal node NODE that matches the multi-character string currently contained in the input FIFO 8.
- it can also contain components for parallel updating of the prefix of the code word used by the coding unit 7, this prefix being updated by the coding unit 7 on the basis of the internal status of the modeling unit 6 and based on the number of different code words which are generated by the modeling unit 6 were transmitted to the coding unit 7.
- both the modeling unit 6 and the coding unit 7 have update components that perform the highly compact coding of output code words and are present in the modeling unit 6 in the form of memory components that refer to the last previous internal node NODE, which in the Trie dictionary memory 4 was used, and that the output code word, which was transmitted to the coding unit 7 is formed as the difference between the last internal node NODE previously used and the current node to be transferred.
- the modeling unit 6, the coding unit 7, the alignment unit 9 and the output FIFO 12 can also contain components for coordinating the parallel operation with different and independent code words and thus form a pipeline, starting with the modeling unit 6, these components being made up of memories in the modeling unit 6, the coding unit 7, the alignment unit 9 and the output FIFO 12, which contain the code word from the output of the previous block and which the modified code word resulting from the processing of this code word within the respective unit during the next pipeline step to the transfer the next unit in the compression chain.
- This pipeline is organized in such a way that a standstill for the modeling unit 6 during the compression process is largely avoided.
- the decompression unit for decompressing digital data blocks contains components for buffering input code words according to the first-in-first-out method as part of the overall data compression system, these input code words encoding different lengths for the original, uncompressed Represent symbols of fixed length.
- the Trie dictionary memory 403 and the literal dictionary 402 are connected to a modeling unit 404, which has components for interacting with the Trie dictionary memory 403, which consists of more than one storage position, which in turn has an output FIFO 406, an interface unit 409, an input FIFO 410, an alignment unit 407 with a decoding unit 405 and the other with a block buffer 408 and is directly connected to the decoding unit 405.
- Alignment unit 407 which converts information provided by input FIFO 410 and aligned on byte boundaries into a variable length code word representation, generates a byte organized data format for decoding unit 405, including components for receiving variable length code words and additional components for determining the correct ones Length of the prefix, the node number, the node type and the relative match length with the node existing in the Trie dictionary memory 403, which is described by the code word, or vice versa, contains the correct bit length of the prefix and the relative number of the individual symbol in the literal dictionary 402 ,
- the decoding unit 405 contains components for interacting with the modeling unit 404 and determines the correct node number and the position of the first symbol and the absolute match length on the basis of the content of the internal registers of the modeling unit 404, the current state of the drive dictionary memory 403 and the code word if the code word is of the node type.
- Modeling unit 404 is also connected in parallel to literal dictionary 402.
- the connection is necessary to transmit the code substitution defined by the literal dictionary 402 if the codeword is of the literal type and contains a component for performing a multibyte copy operation which either contains a previously occurring symbol or a character string from the determined position in the block buffer or output FIFO 406 copied to the current position in the output FIFO 406, the output FIFO 406 containing components for the temporary storage of these code words aligned on byte boundaries until the specified width of the output bus is reached and a suitable point in time is present to transfer the results of the decompression to the output memory via the interface unit 409.
- the modeling unit has 404
- Update components that insert both provisional and final nodes into the trie-dictionary memory 403, the nodes causing the current string in the output memory or the corresponding FIFO, which is identified by a field position 211, the current status of the trie-dictionary memory 403 and the preliminary information previously written into the Trie dictionary memory 403 by the modeling unit 404 speeds up the processing in the event that the final update is identical to the preliminary and consequently the final update is avoided.
- the modeling unit 404 has update components for a parallel update of the literal dictionary 402, which is triggered by a single character addressed via the corresponding input FIFO 410, the update process taking place when the modeling unit 404 determines that that no internal node in the tri-dictionary memory 403 is used by the current code word provided by the decoding unit 405.
- the modeling unit 404 has update components for a parallel update of the prefix of the code word used by the decoding unit 405, the Prefix, which has been updated by the decoding unit 405 based on the internal status of the modeling unit 404 and the number of different code words, is transmitted by the modeling unit 404 to the decoding unit 405, the decoding unit 405 using a self-balancing prefix tree and this tree is the most recent assigns the shortest prefix to the most frequently used type of code words.
- the input FIFO 410, the alignment unit 407, the decoding unit 405, the modeling unit 404 and the output FIFO 406 contain components for coordinating the parallel operation with different and independent code words and thus pipelining, starting with the Alignment unit 407, which components consist of memories in modeling unit 404, decoding unit 405, alignment unit 407 and output FIFO 406, which store the code word from the output of the previous block for the next processing step.
- the pipeline is organized in such a way that the modified code word resulting from the processing of the current code word within the respective unit is transmitted to the next unit in the compression chain during the next pipeline step. This organization of the pipeline chain avoids a standstill for the modeling unit 404 during the decompression process.
- FIG. 5 and FIG. 6 show a practical exemplary embodiment for the compression method which is carried out by the circuit arrangement described, the compression method for the input character string "abcabbcaacbcbcaacx".
- the two initial characters of the chain a [position 0] and b [1] are examined (hash function) to determine whether there is a character string in the Trie dictionary memory 4 that begins with ab. While the dictionary dictionary 4 reports errors, i.e. if such a character string does not exist, the search for the character a in the literal dictionary 2 shows that such a literal has not yet been entered. It is classified as a new literal NLIT, provided with an O-bit prefix and transmitted in its original form [H61]. Meanwhile, the leaf node LEAF I is formed and a is assigned the code word 0 in the literal dictionary 2. The same procedure is repeated for b [1] and c [2], because no matches are found in the dictionary dictionary 4 for these initial symbols.
- a match with I is found for the character string starting from position [3] fig. It is therefore compared with [0].
- the result of the comparison is exactly two characters.
- a leaf node becomes LEAF which describes I as the target node (2 terminal nodes before the current one) and 2 symbols as the match length.
- the update of the dictionary dictionary 4 is carried out by forming a first internal node NODE 1 with a depth of 2 by entering 1 as the parent node of I and the formation of the new leaf node LEAF IV.
- the same procedure is repeated for the character string bcaa. .. in position [5], which finds a match with node II (2 terminal nodes back) and a match of 3 symbols;
- the dictionary dictionary 4 is updated by forming nodes 2 with a depth of 3 and node V.
- the pair b, c at position [10,11] finds a trie match with the internal node NODE 2, which refers to position [5], but the match is too short to reach the match length 3 by this node is represented.
- an internal node NODE 2 is output, along with a match length increased by 1 compared to the parent node.
- the parent node is the symbol b with a depth of 1 and the internal node NODE is only valid for matches of two or more characters, only one bit is used to express the special match length 2, by the Value 0 (a value 1 would mean a match of 3, ie the depth of node 2 itself).
- the next step is to analyze the string bcaacx [12].
- the search steps performed find the node 3 in the Trie dictionary memory 4 and reach its depth of 2, then the node 2 and reach its depth of 3, then the node V, ending the search with a depth of 5.
- a leaf node LEAF (-3.2) generates as the distance with respect to the current terminal node and a depth difference to the parent node of V (node 2).
- the example ends with the coding of x [17] as NLIT and the transmission of "0", [H78] to the alignment unit.
- the process for converting a block of input symbols into encrypted output code words of variable length in a data block compression system will also be explained in a coherent manner.
- the input symbols are transferred to an input FIFO 8.
- a hash address is calculated which is used in parallel in the memory dictionary 4 and to search in the zero finder lookup table 3 in order to quickly be able to determine whether an internal node NODE or a leaf node LEAF exists in the dictionary dictionary memory 4.
- the search in the Trie dictionary memory 4 determines an internal node NODE which matches the character string in the input FIFO 8 in more than one character
- the multi-byte search is continued iteratively until the longest match of the input character string in the input FIFO 8 with existing nodes of the Trie dictionary memory 4 is found. This process is repeated until no matching node is found.
- the node number is encoded in a relative form with respect to the last node formed and the code word is identified either in the Trie dictionary memory 4 as an internal node NODE or as a leaf node LEAF.
- the match length transmitted to the coding unit is calculated in a differential form with respect to the last node passed through during the search.
- the search in the Trie dictionary memory 4 does not find an internal node NODE that matches the character string in the input FIFO 8 in more than one character, it is determined via the literal dictionary 2 whether the code word is known by a known literal KLIT and thus by can display the variable length code assigned to the character when it appeared earlier. Otherwise, the character is identified as New Literal NLIT and is displayed in its original form if it is not yet in Literal Dictionary 2.
- a prefix of variable length is assigned to each code word type in accordance with the type of code word used, this prefix being determined via a self-balancing prefix tree on the basis of the cumulative, current count values for the different code word types.
- the resulting variable-length code word is converted via an alignment operation into an output result aligned to byte boundaries, the aligned output code words in the output FIFO 12 are stored and combined there into groups in order to carry out an efficient write operation on the final storage medium with regard to the point in time and bus width to be able to. In this way, a compressed representation in the form of a block of output code words is generated from an uncompressed block of input symbols.
- a data structure is generated in the dictionary dictionary 4, in which the internal nodes NODE and leaf nodes LEAF coexist in the same dictionary.
- the leaf nodes LEAF start at 1 and are counted up, the internal nodes NODE start with the highest number and are counted down, whereby both types of nodes do not collide with each other. If the search in the dictionary dictionary 4 finds an internal node NODE that matches the character string in the input FIFO 8 in more than one character, but does not match the exact length of every node present in the search path, this dictionary is created of a new internal node NODE updated.
- the count for the number of internal nodes NODE is reduced by 1 and a new leaf node LEAF is formed.
- the depth of this new leaf node LEAF is assigned the value of the maximum length of this character string and there is then an increase in the End node counter by 1. If the search in the Trie dictionary memory 4 detects an internal node NODE that matches the character string in the input FIFO 8 in more than one character and at the same time matches the exact length of a node in the search path, steps are taken to Update of the node reached is carried out, the node reached in its position field receiving the current position pointer in the input data memory.
- This method is also carried out if the internal node NODE is not a leaf node LEAF and in this case steps are taken to create a new leaf node LEAF, this new leaf node LEAF receiving the current position pointer in its position field in the input data memory, whereby finally the end node counter is incremented. If the search in the higher-order dictionary memory 4 does not find an internal node NODE that matches the character string in the input FIFO 8 in more than one character, a new leaf node LEAF is generated in this dictionary, this new leaf node LEAF having the maximum length receives. Finally, the end node counter is incremented.
- the method is also carried out if the input character at the output of the input FIFO 8 is not contained in the literal dictionary 2, the method including the steps for updating the literal dictionary 2 by adding the number to the entry corresponding to the input symbol the new symbols received so far in this block are assigned. Finally, the counter for the known symbols is increased by one.
- One embodiment of the method provides that for decoding the original data block from a coded block of code words, the code words aligned in bytes are entered in the input FIFO 8, that the input FIFO 8 converts these byte-aligned code words of fixed length back into such variable lengths and makes this available as an input variable for the decoding step by assigning these code words to a new literal NLIT, a known literal KLIT, an internal node NODE or a leaf node LEAF on the basis of the dynamic prefix contained in the relevant code word.
- This procedure is carried out when the code word is recognized as a new literal NLIT and there is a single symbol in the code word that is fed directly to the output FIFO 12, or when the code word is recognized as a known literal KLIT and a single symbol from the code word above the literal dictionary 2 is translated back and passed to the output FIFO 12, or if the code word is of the type either an internal node NODE or a leaf node LEAF in the dictionary dictionary memory 4.
- the method reads from the Trie dictionary memory 4 the parent node of the relevant internal node NODE in order to determine the previous block position at which a similar character string exists in the output FIFO 12 and the node depth to the decoder, which returns the number of bits required for the representation of the relative length and the actual relative value itself calculated.
- the calculation is carried out by adding this relative length to the above-mentioned parent node of the internal node NODE, and in this way determining the parameters for the execution of the copying step (s) taking place for several characters.
- This copy process includes all steps to get as many symbols from the position described by the position field of this decoded internal node NODE into the output FIFO 12 to be copied as determined by the aforementioned absolute length of the copy. All these steps are repeated until no further code words have to be decoded and the original symbol block is thus restored from the compressed block of code words.
- Trie dictionary memory 4 updated by forming a new leaf node LEAF, which new leaf node LEAF receives the current position pointer in the input data memory in its position field. Finally, the end node counter is incremented. A new internal node NODE is formed, this new internal node NODE receiving the current position pointer in the output FIFO 12 in its position field. The depth of this new internal node NODE is assigned the absolute match length of the character string, which was calculated in the decoding process. Finally, the counter for the number of internal nodes NODE is counted down by one.
- Trie Dictionary memory 4 If a code word is extracted which corresponds to an internal node NODE in the Trie dictionary memory 4 and the absolute length match, calculated from the sum of the length of this code word and the depth of the father node, matches the node depth of this node itself, the Trie Dictionary memory 4 is updated by forming a new leaf node LEAF, this new leaf node LEAF receiving the current position pointer in the output FIFO 12 in its position field. Finally, the end node counter is incremented.
- the prefixes of the code word types can be updated both during compression and during decompression.
- the prefixes can be updated as soon as any of the elements of the pairs [known literal KLIT, leaf node LEAF] and [new literal NLIT, internal node NODE], the counter becomes larger than the counter reading of the other element of the pair and this larger element now receives the shorter coding available for the pair and this element now has the largest element of the other pair and in turn assigning the shorter encoding to the largest element, whereby the prefix tree balances itself to assign the shorter prefix to the more common code word type.
- Decompression process can be modified dynamically, or to define the initial values for the prefixes in the static case as follows:
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Compression, Expansion, Code Conversion, And Decoders (AREA)
Description
Blockdatenkompressionssystem, bestehend aus einer Kompressionseinrichtung und einer Dekompressionseinrichtung, und Verfahren zur schnellen Blockdatenkompression mit Multi-Byte-Suche
Die Erfindung bezieht sich auf ein Blockdatenkompressionssystem, bestehend aus einer Kompressionseinrichtung und einer Dekompressionseinrichtung, und ein Verfahren zur schnellen Blockdatenkompression mit Multi-Byte-Suche im Bereich der Datenkompression sowie insbesondere auf eine verlustfreie, adaptive und reversible digitale Schaltungsanordnung zur schnellen Blockdatenkompression in Speicher- und Telekommunikationsgeräten.
Die digitale Datenkompression ist ein bekanntes Mittel zur Reduzierung des Platzbedarfs in Massenspeichergeräten. Gleichzeitig wird durch die Datenkomprimierung eine Minimierung der Datenübertragungszeit in Netzen, bei Satellitenverbindungen und ähnlichen Anwendungen erreicht. Die immer rascher zunehmenden Mengen an Informationen, die von modernen Systemen verarbeitet, übertragen und gespeichert werden, stellen eine Herausforderung an moderne Anwendungen dar, so daß Datenkompression entsprechend wichtig wird.
In den vergangenen Jahren wurden erhebliche Anstrengungen unternommen, um allgemeingültige effiziente Datenkompressionsverfahren zu entwickeln, die in der Lage sind, sich selbst an unterschiedliche Informationstypen anzupassen und im Vergleich mit spezifisch orientierten Verfahren, die auf einer weiterreichenden Kenntnis der Eigenschaften der Informationen basieren, gleichwertige Ergebnisse liefern. Zur Erreichung dieser Eigenschaften sollten derartige Datenkompressionssysteme idealerweise schnell in der Lage sein, eine hinreichend gute Kompressionsrate zu erzielen, auf der anderen Seite aber nur eine begrenzte Komplexität aufweisen.
Die in den letzten Jahren veröffentlichten Arbeiten waren vorrangig darauf orientiert, möglichst beiden Forderungen zu entsprechen bzw. einen optimalen Kompromiß zu erzielen. Die Wurzeln von Datenkompressionsverfahren basieren auf der in den meisten Arten von Daten vorhandenen Redundanz. Es ist unstreitig, daß Kommunikation menschlicher Art nicht optimal ist, wie dies beispielsweise an Textdateien ersichtlich ist. Verfahren, bei denen zunächst die Statistik bzw. lexikalische Regeln erfaßt werden und anschließend der Kompressionsprozess erfolgt, werden als "Offline"-Verfahren bezeichnet. Ein allgemeiner Nachteil dieses Prinzips ist die Notwendigkeit, zusätzliche Informationen bezüglich dieser Statistiken zu übertragen. Demgegenüber wird ein Verfahren als adaptiv bezeichnet, wenn die Kompression auf der Grundlage der bereits verarbeiteten Informationen erfolgt, was in den meisten Fällen durch einen einstufigen Online-Prozess in einem Verarbeitungsschritt erfolgt.
Für die Datenkompression gibt es bereits eine große Zahl früherer Konzepte. D.A. Huffman schlägt in "A method for the construction of minimum redundancy codes"; Proceedings of the IRE; Vol. 40; 1952; S. 1198-1110, einen klassischen Algorithmus vor, bei dem Symbole fester Länge des Eingangsalphabets (beispielsweise Bytes) auf der Grundlage der statistischen Wahrscheinlichkeit des
Auftretens dieser Symbole innerhalb des Kontextes des gesamten Strings oder der kompletten Eingabedatei Codes von variabler Länge zugewiesen werden.
Die nächste Generation von Huffmann-Codes war auf die Umwandlung in einen einstufigen Algorithmus und seine Adaptierbarkeit an Kontextänderungen gerichtet. Damit war der Algorithmus in der Lage, bei der Kompression die Auftretenswahrscheinlichkeiten der bereits verarbeiteten Symbole für die Codierung des nächsten ankommenden Symbols zu berücksichtigen (vgl. D.E. Knuth, "Dynamic Huffman codes"; Journal of Algorithms, Vol. 6, No. 2; Juni 1985; S. 163-180; J.S. Vittier; "Design and analysis of dynamic Huffman codes"; Journal of the ACM; Vol. 34; No. 4; Oktober 1987; S. 825-845; sowie J.S. Vittier, "Dynamic Huffman coding"; ACM Transaction on Mathematical Software; Vol. 15; No. 2; Juni 1989; S. 158-167).
Vor kurzem wurde ein Weg entdeckt, mit dem der unnötige Aufwand vermieden wird, den aus der Informationsentropie resultierenden gebrochenen Teil [Log P(X|)*P(Xj)] in eine ganzzahlige Anzahl von Bits zu codieren. Das führt zur sogenannten arithmetischen Codierung. Die Vorteile dieses Codierungsverfahrens liegen auf der Hand, da seine Optimalität hinsichtlich der Entropie ausschließlich durch praktische Erwägungen bezüglich der erforderlichen Rechengenauigkeit begrenzt wird. In der Regel besitzt das erhaltene Ergebnis im Vergleich zur theoretischen Entropie nur sehr kleine Abweichungen.
Dennoch ist keine der vorgenannten Verfahren der ersten Ordnung in der Lage, die in den meisten Datentypen vorhandene Korrelation zwischen einem Teilstring und dem nächsten Zeichen zu nutzen. Zur Veranschaulichung dieser Aussage betrachten wir den Fall, daß der Buchstabe "q" das letzte verarbeitete Symbol darstellt. Sowohl in der deutschen als auch in der englischen Sprache (wie auch in anderen) ist die Wahrscheinlichkeit, daß ein "u" als nächstes Eingangszeichen folgt, recht hoch - unabhängig davon, wie häufig dieses Zeichen bereits im vorhergehenden String auftrat bzw. gar nicht darin vorkam. Auf Grund dieser Tatsache ist die erreichbare Kompressionsrate dieser Verfahren erster Ordnung begrenzt. Die im folgenden beschriebenen Kompressionsverfahren höherer Ordnung erreichen in der Regel höhere Kompressionsraten. Modelle höherer Ordnung wurden auch für die statistischen Verfahren entwickelt; vgl. beispielsweise Cleary et al; "Unbounded Length Contexts for PPM"; Data Compression Conference (DCC'95), 1995. Die Leistungssteigerung ist jedoch mit erheblichen Geschwindigkeitsverlusten sowie Speicherbedarf verbunden.
Ein anderes Prinzip zur Datenkompression wurde 1977 und später 1978 von J. Ziv und Lempel vorgestellt. Dieses Prinzip ist aus einer anderen Familie von Kompressionsalgorithmen abgeleitet, die üblicherweise als substitutiv bezeichnet werden. Der diesen Ideen zu Grunde liegende Gedanke war es, ein Kopie- Codewort zu erzeugen, daß nach Möglichkeit das frühere (oder eines der früheren) Vorkommen des nächsten eingehenden Teilstrings ausdrückt. Andernfalls wird das nächste Zeichen auf der Ausgangsseite in seiner ursprünglichen Form ausgedrückt. Beide Arten von Codeworten werden entsprechend markiert. Zwei Artikel dieser Verfasser haben zu unterschiedlichen Vorgehensweisen bezüglich der Bestimmung und des Aufbaues der Kopie- Codeworte geführt.
In "A universal algorithm for sequential data compression"; IEEE Transaction on Information Theory; IT-23; No. 3; 1977; S. 337-343; wird ein Fensterkonzept vorgestellt. In der Fachliteratur wird dieses Konzept auch als ZL1 oder "Sliding Dictionary" (gleitendes Wörterbuch) bezeichnet. Das wesentliche Merkmal dieses Algorithmus besteht aus einem Fenster, das entlang der unkomprimierten Eingangsdaten verschoben wird. Bei jedem Schritt wird untersucht, ob die ankommende Teilzeichenkette mit einer beliebigen Zeichenkette innerhalb des Fensters übereinstimmt. Ziel ist die Bestimmung der längsten identischen Zeichenkette. Als Ergebnis der Suche wird ein Paar <Position, Länge> ermittelt, das diese Eingangszeichenkette hinsichtlich der Übereinstimmung mit der entsprechenden Zeichenkette im Fenster eindeutig beschreibt. Dieses Paar wird sodann codiert und dem codierten Datenstrom zugeführt. Im Anschluß daran wird das Fenster so weiterbewegt, daß es die übereinstimmende Teilzeichenkette enthält, wobei gegebenenfalls die ältesten Zeichen aus dem Fenster herausfallen, um die Länge des Fensters konstant zu halten. Falls die Teilzeichenkette am Eingang nicht mit der Zeichenkette innerhalb des Fensters in zwei oder mehr Symbolen (bis zur Grenzlänge) übereinstimmt, wird das ankommende Zeichen bzw. werden die ankommenden Zeichen in der Originalform - auch als "Literal" bezeichnet - im Ausgangsdatenstrom dargestellt. Beide Fälle werden in geeigneter weise markiert, um die Decodierung zu ermöglichen.
Es wurden erhebliche Anstrengungen unternommen, um die in diesem Algorithmus enthaltene Suchfunktion effektiver zu gestalten, wobei es in den verschiedenen Betriebssystemen eine Vielzahl praktischer Software- Implementierungen gibt. Verbesserungen dieses Konzepts wurden vom ehemaligen Stac populär gemacht (durch das unter der Bezeichnung LZSS bekannte Verfahren). Dies findet seinen Ausdruck in den Patentschriften US 5016009, US 5126739, US 5414425, US 5463390 und US 5506580 von D.L. Whiting et al. Eine Beschreibung der Suchstrategien und Veränderungen von ZL1 findet sich in T. Bell; "Modeling for text compression"; ACM Computer Surveys; Vol. 21 ; Nr. 4; Dezember 1989; S. 557-591. Ein grundlegenden Merkmal dieses Konzepts ist, daß der Positionszeiger auf die Zeichenposition im Fenster zeigt, an der die übereinstimmende Zeichenkette beginnt. Im weiteren Text wird dies als "externe" Darstellung des Zeigers bezeichnet. Die Gründe hierfür ergeben sich aus der folgenden Beschreibung der Erfindung.
Eine der größten Schwächen von ZL1 ist der langsame Suchvorgang. Deshalb wird bei praktischen Anwendungen eine zusätzliche Datenstruktur zur Beschleunigung des Suchvorganges eingeführt. Sie enthält normalerweise die letzte(n) Adresse(n) des Auftretens jedes einzelnen Symbols (das gleichzeitig auch den Beginn einer Zeichenkette repräsentiert) im Eingangsdatenstrom und wird bei jedem erneuten Auftreten mit der neuen Adresse aktualisiert (d.h. die älteste Adresse entfällt). Das Einfügen bzw. Aktualisieren sämtlicher Teilzeichenketten, die an jeder externen Position beginnen, ist eine zeitaufwendige Prozedur, so daß sich eine Begrenzung der maximal erreichbaren Länge erforderlich macht. Weiterhin macht sich eine Beschränkung der gespeicherten Adressenzahl des Auftretens dieses Symbols erforderlich (z.B. die letzten drei). Damit ist die Suche u.U. nicht vollständig und führt ggf. zu nicht optimalen Ergebnissen.
Als Lösung für diese Einschränkungen wird in der Patentschrift US 5612693 eine Hardware-Architektur vorgeschlagen, die später in den Patentschriften US 5627534, US 5874907 und US 5877711 von Craft, DJ., verbessert wird. Hierbei wird die Verwendung eines speziellen "inhaltadressierbaren Speichers" (Content Addressable Memory (CAM)) für die Durchführung einer parallelen Suche in einem Fenster von begrenzter Größe mittels eines als ALDC bezeichneten Verfahrens vorgeschlagen. Die mit diesem Verfahren realisierte umfassende Suche kompensiert die reduzierte Fenstergröße (als Ergebnis der technologischen Komplexität des CAM-Speichers), wobei nach Aussagen des Verfassers die Gesamt-Kompressionsraten denen von LZSS vergleichbar sind.
Eine andere Herangehensweise für das Substitutiv-Verfahren wird von J. Ziv, A. Lempel beschrieben in: "Compression of individual sequences via variable-rate coding"; IEEE Transaction on Information Theory; IT-24, No. 5; September 1978; S. 530-536. Hierauf basiert die Patentschrift US 4464650 von W.L. Eastman, J. Ziv, A. Lempel et al; "Apparatus and methods for compressing data Signals and restoring the compressed data". Weitere Verbesserungen sind in der Patentschrift US 4558302 von T. Welch enthalten. Hierauf wird an späterer Stelle einzugehen sein, da dieses Verfahren eine Zeitlang sehr verbreitet war. Zu weiteren Einzelheiten vgl. auch T. Welch "A Technique for High Performance Data Compression"; Computer; Vol. 17; Nr. 6; Juni 1984; S. 8-19.
Bei Ziv-Lempel-Welch (ZLW) wird ein dynamisches Wörterbuch konstruiert (daher auch die Bezeichnung "Dynamic Dictionary Method" (Dynamisches Wörterbuch- Verfahren)), das Teilzeichenketten variabler Länge enthält. Wenn eine Übereinstimmung zwischen einer ankommenden Teilzeichenkette und einem Wörterbuchelement gefunden wird, wird diese Zeichenkette durch die Adresse des entsprechenden Elementes im Dictionary ersetzt. Das Wörterbuch enthält im unteren Adreßbereich auch alle Einzelzeichen des Eingangsalphabets. Einzelne Zeichen im Eingangsdatenstrom, die nicht Bestandteil der im Wörterbuch enthaltenen Zeichenketten (mindestens 2 Zeichen) sind, werden daher durch die Adressen der Einzelzeichen im Wörterbuch dargestellt und zum Ausgang übertragen. Wenn beim Suchvorgang des ZLW eine übereinstimmende Zeichenkette ZK (am Anfang bestehend aus 2 Zeichen, in jeder Iteration ein Zeichen zusätzlich) im Wörterbuch gefunden wird, wird erneut mit dem Paar <ZK, nächstes Zeichen> gesucht, bis eine Nichtübereinstimmung gefunden wird, d.h. die aktuell gesuchte Zeichenkette nicht im Wörterbuch vorhanden ist. Gleichzeitig wird in den Ausgangsdatenstrom die Adresse der letzten übereinstimmenden Wörterbucheintragung eingefügt und das nicht übereinstimmende Paar <Teilstring, letztes Zeichen> dem Wörterbuch auf einer neuen Adresse hinzugefügt, d.h. ZLW kann pro Codierungsschritt Wörterbucheintragungen nur um ein Zeichen erweitern. Anschließend wird die Bearbeitung der Eingangszeichenkette mit dem letzten, nicht übereinstimmenden Zeichen fortgesetzt. Daraus folgt, daß Zeichenketten innerhalb der Wörterbucheintragungen (z.B. in 'abcde': 'bcde', 'cde' und 'de') vom Verfahren nicht verarbeitet werden. Weiterhin ist das Verfahren nicht in der Lage, beim ersten Auftreten einer Zeichenkette diese im Ausgangsdatenstrom mit der Adresse des erfolgten Neueintrags abzubilden. Im Ausgangsdatenstrom wird an
dieser Stelle die Adresse der nächstkürzeren Zeichenkette eingesetzt. Erst beim zweiten Auftreten wird die entsprechende Wörterbucheintragung wirksam.
Bei dieser Art von Kompression sind Hashing-Verfahren hilfreich, so daß der Speicherbedarf für das Wörterbuch innerhalb vernünftiger Grenzen gehalten wird und die Geschwindigkeit der Suche im Wörterbuch gesteigert werden kann. Unabhängig davon ist ZLW nicht in der Lage, charakteristische Zeichenketten der Eingangsdaten schnell "zu lernen", die Aktualisierung des Wörterbuches ist ein iterativer Prozeß. Daher existiert ein Nicht-Null-Schwellenniveau, von dem an das Verfahren effizient zu arbeiten beginnt. Dies bedeutet, daß das Verfahren bei kurzen Durchläufen im Vergleich zu konkurrierenden Verfahren relativ enttäuschende Ergebnisse liefert. Die erreichten Kompressionsraten liegen allgemein geringfügig unter den mit ZLSS erzielten Ergebnissen. Weitere Schwächen zeigen sich, wenn man versucht, das Verfahren in einem kontinuierlichen Strom von Eingabezeichenketten anzuwenden, wenn das Wörterbuch voll ist.
In der Patentschrift 4906991 von Fiala et al, wird eine von R. Morrison in "Patricia- Practical Algorithm to retrieve information coded in alphanumeric" (Journal of the ACM; Vol. 15; Nr. 4; 1968; S. 513-534) vorgestellte spezielle Baumstruktur, der sogenannte "Suffix-Trie", weiterentwickelt, in der eine Reihe von modifizierten Kompressionsalgorithmen vorgeschlagen wurden, die von der externen Darstellung in ZL1 bis zur (internen) Wörterbuchmethode in ZL2 reichen. Ein zentrales Element dieser Kompressionsverfahren ist jedoch bedauerlicherweise die Zusammenfassung mehrerer nicht komprimierter Symbole in einem einzigen Codewort (mit vorangestellter Zeichenzahl). Das hat eine hohe Verzögerungszeit bei der Ausgabe des komprimierten Datenstroms zur Folge. Weiterhin erfordert dieses grundsätzlich softwarebasierte Datenkompressionsverfahren auf Basis der "Trie"-Struktur erheblichen Speicherplatz, so daß seine Implementierung in Hardwarelösungen nicht möglich war.
Spätere Arbeiten zur Verwendung von "Trie"-Strukturen zur Erzeugung dynamischer Wörterbücher werden in den Patentschriften US 5406279 von Anderson, US 5640551 von Chou sowie US 6012061 von Sharma beschrieben. Diese konzentrieren sich jedoch auf zusätzliche Techniken zur Führung/ Aktualisierung des Trie-Wörterbuchs, wenn dieses als Folge der Verarbeitung von großen Eingabedateien voll wird. Weder erfolgte eine Auseinandersetzung mit den eingangs geschilderten Beschränkungen noch die Schaffung von Schlüsselbedingungen, die für schnelle Hardware-Datenkompressionslösungen erfüllt sein müssen.
Aufgabe der Erfindung ist es, ein Blockdatenkompressionssystem, bestehend aus einer Kompressionseinrichtung und einer Dekompressionseinrichtung, und ein Verfahren zur schnellen Blockdatenkompression mit Multi-Byte-Suche zur optimalen Codierung während der Lernphase substitutiver Methoden zu entwickeln, bei dem in der Länge begrenzte und relativ kleine Teile der Eingabedatei unabhängig voneinander komprimiert werden können, wie dies bei Direktzugriffsspeichergeräten oder Telekommunikationsgeräten gefordert ist, und die eine hohe Leistungsfähigkeit durch eine Reihe von beschleunigenden Architekturstrukturen sowie Datenflußprinzipien, beispielsweise ein hochgradiges Pipelining, erlauben.
Erfindungsgemäß wird die Aufgabe durch ein Blockdatenkompressionssystem, bestehend aus einer Kompressionseinrichtung und einer Dekompressionseinrichtung gelöst, wobei die Kompressionseinrichtung einen Input-FIFO enthält, um Eingangssymbole nach dem First-in-first-out Prinzip zu puffern, und dieser Input FIFO mit einer Steuerungskomponente, einer Modellierungseinheit verbunden ist, wobei diese Modellierungseinheit mit einem Trie-Wörterbuchspeicher, einer Zero-Finder-Lookup-Tabelle, Suchkomponenten in Form einer Vergleichseinheit, Speicherkomponenten in Form eines Literal- Wörterbuches und einer Codierungseinheit verbunden ist. Die Codierungseinheit ist wiederum über eine Ausrichtungseinheit mit einem Output-FIFO verbunden. Der Trie-Wörterbuchspeicher besteht aus einer Vielzahl von Speicherstellen, wobei die Modellierungseinheit parallel auf diesen zugreift, und das Wörterbuch höherer Ordnung bildet, das durch eine Hash-Funktion adressiert wird, die aus den ersten Zeichen, die im Input-FIFO enthalten sind, berechnet wird. Die Zero- Finder-Lookup-Tabelle dient zur Vorausbestimmung ungenutzten Platzes im Wörterbuch höherer Ordnung, wobei die Modellierungseinheit auf das Wörterbuch höherer Ordnung zugreift, um zu bestimmen, ob die im Input FIFO enthaltene Zeichenkette durch einen beliebigen inneren oder externen Knoten, der in diesem Wörterbuch existiert, ersetzt werden kann. Die Vergleichseinheit führt dabei den parallelen Vergleich mehrerer Zeichen durch, um die maximale Länge der Übereinstimmung zwischen dem betreffenden Knoten in diesem Wörterbuch und der Zeichenkette im Input-FIFO zu bestimmen. Das Literal-Wörterbuch bildet das Wörterbuch niedriger Ordnung, wobei der Inhalt des Literal-Wörterbuches zur Erzeugung der codierten Form für Zeichenketten der Länge 1 in der Modellierungseinheit genutzt wird. Die Modellierungseinheit bestimmt, ob das Ergebnis der parallelen Suche in der Vergleichseinheit oder der Inhalt des Literal- Wörterbuches als Ausgangsgröße der Modellierungseinheit gewählt wird. Die Modellierungseinheit führt sowohl eine iterative parallele Suche durch, wenn ein oder mehrere im Trie-Wörterbuchspeicher enthaltene Knoten die Übereinstimmungslänge mit der im Input-FIFO befindlichen Zeichenkette erhöhen, als auch ein Pipelining der Ergebnisse zur Codierungseinheit, die kompakte Ausgangscodeworte variabler Länge erzeugt, die eine relative Darstellung der Ausgangswerte der Modellierungseinheit verwendet, wobei die Ausgangscodeworte vom aktuellen Zustand der Codierungseinheit abhängig sind. Die Codierungseinheit enthält Komponenten zum Pipelining dieses Ausgangscodewortes variabler Länge zur Ausrichtungseinheit, die das Ausgangscodewort variabler Länge in ein an Bytegrenzen ausgerichtetes Codewort umwandelt. Der Output-FIFO enthält Komponenten zur temporären
Speicherung dieser an Bytegrenzen ausgerichteten Codeworte, bis die spezifizierte Breite des Ausgangsbusses erreicht wird und ein geeigneter Ausgabezeitpunkt vorliegt, um auf diese Weise einen Block von nichtkomprimierten digitalen Eingabedaten mit Hilfe des Kompressionsprozesses in einen komprimierten Datenstrom zur Ausgabe über den Ausgabebus des Output-FIFO umzuwandeln.
Nach einer Ausbildung der Erfindung enthält die Modellierungseinheit Aktualisierungskomponenten zur Einfügung sowohl der vorläufigen als auch der endgültigen Informationen in das Wörterbuch höherer Ordnung, die bewirken, daß die aktuelle Zeichenkette am Ausgang des Input-FIFO den aktuellen Status des Trie-Wörterbuchspeichers, der das Wörterbuch höherer Ordnung enthält, beeinflußt, wobei die vorläufige Information den Kompressionsprozeß für den Fall beschleunigt, daß das endgültige Update mit dem vorläufigen Update identisch ist und demzufolge dieses endgültige Update vermieden wird.
Es ist aber auch möglich, daß die Modellierungseinheit Komponenten zur parallelen Aktualisierung des Literal-Wörterbuches enthält, wobei diese von einem einzelnen Zeichen am Ausgang des Input-FIFOS bewirkt wird und dann stattfindet, wenn das Literal-Wörterbuch nicht in der Lage ist, eine vorangegangene Codierung für das Zeichen am Ausgang des Input-FIFOs zu finden, und der Trie-Wörterbuchspeicher keinen Internen Knoten NODE findet, der mit der aus mehreren Zeichen bestehenden Zeichenkette, die aktuell im Input-FIFO enthalten ist, übereinstimmt.
Sie kann aber auch Komponenten zur parallelen Aktualisierung des Präfixes des von der Codierungseinheit verwendeten Codewortes enthalten, wobei dieses Präfix durch die Codierungseinheit auf der Grundlage des internen Status der Modellierungseinheit aktualisiert wird und auf der Anzahl unterschiedlicher Codeworte beruht, die durch die Modellierungseinheit zur Codierungseinheit übertragen wurden.
Eine weitere Möglichkeit besteht darin, daß sowohl die Modellierungseinheit als auch die Codierungseinheit Aktualisierungskomponenten besitzen, die die hochkompakte Codierung von Ausgangscodeworten durchführen und in Form von Speicherkomponenten in der Modellierungseinheit vorhanden sind, die auf den letzten vorhergehenden Internen Knoten NODE verweisen, der im Trie- Wörterbuchspeicher benutzt wurde, und daß das Ausgangscodewort, das zur Codierungseinheit übertragen wurde als Differenz des letzten vorangehenden genutzten Internen Knotens NODE und des aktuellen, zu übertragenden Knotens gebildet wird.
Die Modellierungseinheit, die Codierungseinheit, die Ausrichtungseinheit und der Output-FIFO können aber auch Komponenten zur Koordination des Parallelbetriebes mit unterschiedlichen und unabhängigen Codeworten enthalten und damit eine Pipeline, beginnend mit der Modellierungseinheit, bilden, wobei diese Komponenten aus Speichern in der Modellierungseinheit, der Codierungseinheit, der Ausrichtungseinheit und dem Output-FIFO bestehen, die das Codewort vom Ausgang des vorangegangenen Blockes enthalten und die das sich aus der Verarbeitung dieses Codewortes innerhalb der jeweiligen Einheit
ergebende modifizierte Codewort während des nächsten Pipelineschrittes an die nächste Einheit in der Kompressionskette übertragen. Diese Pipeline ist dabei dergestalt organisiert, daß ein Stillstand für die Modellierungseinheit während des Kompressionsvorgangs weitestgehend vermieden wird.
Nach einer Ausführungsform der Erfindung enthält die Dekompressionseinheit zur Dekompression digitaler Datenblöcke als Bestandteil des gesamten Datenkompressionssystems Komponenten zur Pufferung von Eingabe- Codeworten nach dem First-in-first-out-Verfahren, wobei diese Eingabe- Codeworte eine Codierung unterschiedlicher Länge für die ursprünglichen, nichtkomprimierten Symbole fester Länge repräsentieren. Der Trie- Wörterbuchspeicher und das Literal-Wörterbuch sind dabei mit einer Modellierungseinheit, die Komponenten für das Zusammenwirken mit dem aus mehr als einer Speicherposition bestehenden Trie-Wörterbuchspeicher besitzt, verbunden, die ihrerseits zum einen über einen Output-FIFO, eine Interface- Einheit, einen Input-FIFO, eine Ausrichtungseinheit mit einer Decodierungseinheit und zum anderen mit einem Blockpuffer und direkt mit der Decodierungseinheit verbunden ist. Die Ausrichtungseinheit, die vom Input-FIFO gelieferte und an Bytegrenzen ausgerichtete Information in eine Codewortdarstellung variabler Länge umwandelt, erzeugt ein Byte-organisiertes Datenformat für die Decodierungseinheit, wobei sie Komponenten zum Empfang von Codeworten variabler Länge und zusätzlich Komponenten zur Bestimmung der korrekten Länge des Präfixes, der Knotennummer, des Knotentyps und der relativen Übereinstimmungslänge mit dem im Trie-Wörterbuchspeicher existierenden Knoten, der durch das Codewort beschrieben wird, oder umgekehrt die korrekte Bitlänge des Präfixes und die relative Nummer des Einzelsymbols im Literal- Wörterbuch, enthält. Die Decodierungseinheit enthält Komponenten zum Zusammenwirken mit der Modellierungseinheit und ermittelt auf der Basis des Inhaltes der internen Register der Modellierungseinheit, des aktuellen Zustandes des Trie-Wörterbuchspeichers und aus dem Codewort die richtige Knotennummer und die Position des ersten Symbols sowie die absolute Übereinstimmungslänge, falls das Codewort vom Node-Typ ist. Die Modellierungseinheit ist auch parallel mit dem Literal-Wörterbuch verbunden. Die Verbindung ist nötig, um die durch das Literal-Wörterbuch definierte Code-Substitution zu übertragen, falls das Codewort vom Literal-Typ ist und eine Komponente zum Ausführen einer Multibyte-Kopieroperation enthält, die entweder ein früher aufgetretenes Symbol oder eine Zeichenkette aus der ermittelten Position im Blockpuffer oder Output- FIFO zu der aktuellen Position im Output-FIFO kopiert, wobei der Output-FIFO Komponenten zur temporären Speicherung dieser an Bytegrenzen ausgerichteten Codeworte enthält, bis die spezifizierte Breite des Ausgangsbusses erreicht wird und ein geeigneter Zeitpunkt vorliegt, um die Ergebnisse der Dekompression über die Interface-Einheit zum Ausgangsspeicher zu übertragen.
Bei dieser Variante besitzt die Modellierungseinheit Aktualisierungskomponenten, die sowohl vorläufige als auch endgültige Knoten in den Trie-Wörterbuchspeicher einfügen, wobei die Knoten bewirken, daß die aktuelle Zeichenkette im Ausgabespeicher oder dem entsprechenden FIFO, die durch ein Feld Position gekennzeichnet ist, den aktuellen Status des Trie-Wörterbuchspeichers beeinflußt, und wobei die vorläufige Information, die vorher durch die Modellierungseinheit in den Trie-Wörterbuchspeicher geschrieben wurde, den
Verarbeitungsprozeß für den Fall beschleunigt, daß die endgültige Aktualisierung mit der vorläufigen identisch ist und demzufolge die endgültige Aktualisierung vermieden wird.
Es ist aber auch möglich, daß die Modellierungseinheit
Aktualisierungskomponenten für ein paralleles Update des Literal-Wörterbuches besitzt, das von einem einzelnen, über den entsprechenden Input-FIFO adressierten Zeichen ausgelöst wird, wobei der Aktualisierungsprozeß stattfindet, wenn die Modellierungseinheit feststellt, daß kein interner Knoten im Trie- Wörterbuchspeicher durch das aktuelle Codewort genutzt wird, das durch die Decodierungseinheit geliefert wird.
Weiterhin ist möglich, daß die Modellierungseinheit Aktualisierungskomponenten für eine parallele Aktualisierung des Präfixes des von der Decodierungseinheit verwendeten Codewortes besitzt, wobei das Präfix, das durch die Decodierungseinheit auf der Grundlage des internen Status der Modellierungseinheit und der Anzahl der unterschiedlichen Codeworte aktualisiert wurde, durch die Modellierungseinheit zur Decodierungseinheit übertragen wird, wobei die Decodierungseinheit einen selbstbalancierenden Präfix-Baum verwendet und dieser Baum dem am häufigsten verwendeten Typ von Codeworten das kürzeste Präfix zuordnet.
Letztlich ist es aber auch möglich, daß der Input-FIFO, die Ausrichtungseinheit, die Decodierungseinheit, die Modellierungseinheit und der Output-FIFO Komponenten zur Koordination des Parallelbetriebes mit unterschiedlichen und unabhängigen Codeworten enthalten und damit ein Pipelining, beginnend bei der Ausrichtungseinheit, ausgeführt wird, wobei diese Komponenten aus Speichern in der Modellierungseinheit, der Decodierungseinheit, der Ausrichtungseinheit und dem Output-FIFO bestehen, die das Codewort vom Ausgang des vorangegangenen Blockes für den nächsten Bearbeitungsschritt speichern. Dabei ist die Pipeline so organisiert, daß das aus der Verarbeitung des aktuellen Codewortes innerhalb der jeweiligen Einheit ergebende modifizierte Codewort während des nächsten Pipelineschrittes an die nächste Einheit in der Kompressionskette übertragen wird. Durch diese Organisation der Pipelinekette wird ein Stillstand für die Modellierungseinheit während des Dekompressionsvorgangs vermieden.
Das Verfahren zur Wandlung eines Blocks von Eingabesymbolen in verschlüsselte Ausgabecodeworte variabler Länge in einem Datenblock- Kompressionssystem, wird erfindungsgemäß dadurch gelöst, daß die Eingangssymbole in einen Input-FIFO übertragen werden, daß auf der Grundlage der ersten beiden Symbole am Ausgang des Input-FIFO eine Hash-Adresse berechnet wird, die dazu benutzt wird, parallel im Trie-Wörterbuchspeicher und in der Zero-Finder-Lookup-Tabelle zu suchen, um schnell feststellen zu können, ob ein Interner Knoten oder ein Blattknoten im Trie-Wörterbuchspeicher existiert. Wenn die Suche im Trie-Wörterbuchspeicher einen Internen Knoten feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO übereinstimmt, wird die Multi-Byte-Suche iterativ fortgesetzt, bis die längste Übereinstimmung der Eingangszeichenkette im Input-FIFO mit existierenden Knoten des Trie- Wörterbuchspeichers gefunden ist. Dieser Prozeß wird wiederholt, bis kein
übereinstimmender Knoten mehr gefunden wird. Die Knotennummer wird in relativer Form bezüglich des letzten gebildeten Knotens codiert und das Codewort wird entweder als Interner Knoten oder als Blattknoten im Trie- Wörterbuchspeicher identifiziert. Die zur Codierungseinheit übertragene Übereinstimmungslänge wird in differentieller Form bezüglich des letzten bei der Suche durchlaufenen Knotens berechnet. Wenn die Suche im Trie- Wörterbuchspeicher keinen Internen Knoten feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO übereinstimmt, wird über das Literal- Wörterbuch festgestellt, ob das Codewort durch ein Bekanntes Literal und damit durch den Code variabler Länge dargestellt werden kann, der dem Zeichen bei seinem früheren Auftreten zugewiesen wurde. Anderenfalls wird das Zeichen als Neues Literal identifiziert und wird in der Originalform dargestellt, wenn es noch nicht im Literal-Wörterbuch enthalten ist. Jedem Codewort-Typ wird ein Präfix variabler Länge entsprechend dem verwendeten Typ des Codeworts zugewiesen, wobei dieses Präfix über einen selbstbalancierenden Präfix-Baum auf der Grundlage der kumulierten, aktuellen Zählwerte für die unterschiedlichen Codewort-Typen ermittelt wird. Dabei wandelt sich das sich ergebende Codewort variabler Länge über eine Ausrichtungsoperation in ein an Bytegrenzen ausgerichtetes Ausgabeergebnis um, die ausgerichteten Ausgabe-Codeworte im Output FIFO werden gespeichert und dort zu Gruppen zusammenfaßt, um eine effiziente Schreiboperation auf das endgültige Speichermedium hinsichtlich Zeitpunkt und Busbreite durchführen zu können. Auf diese Weise wird aus einem nicht komprimierten Block von Eingangssymbolen eine komprimierte Darstellung in Form eines Blocks von Ausgabe-Codeworten erzeugt.
Dabei ist es vorteilhaft, wenn sowohl für den Trie-Wörterbuchspeicher als auch für das Literal-Wörterbuch dynamische Wörterbücher verwendet werden und wenn zusätzliche Schritte zur Aktualisierung des Trie-Wörterbuchspeichers und des Literal-Wörterbuchs enthalten sind. Es wird eine Datenstruktur im Trie- Wörterbuchspeicher erzeugt, bei der Interne Knoten und Blattknoten nebeneinander im selben Wörterbuch existieren. Die Blattknoten beginnen dabei bei 1 und werden aufwärts gezählt, die Internen Knoten beginnen mit der höchsten Zahl und werden abwärts gezählt, wobei beide Knotenarten nicht miteinander kollidieren. Wenn die Suche im Trie-Wörterbuchspeicher einen Internen Knoten feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO übereinstimmt, jedoch in der exakten Länge mit jedem in dem Suchpfad vorhandenen Knoten nicht übereinstimmt, wird dieses Wörterbuch durch Erzeugen eines neuen Internen Knotens aktualisert. Der Zählerstand für die Zahl der Internen Knoten wird um 1 erniedrigt, und es wird ein neuer Blattknoten gebildet. Diesem neuen Blattknoten wird als Tiefe der Wert der Maximallänge dieser Zeichenkette zugewiesen und es erfolgt abschließend ein Erhöhen des Endknotenzählers um 1. Wenn die Suche im Trie-Wörterbuchspeicher einen Internen Knoten feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO übereinstimmt und gleichzeitig in der exakten Länge mit einem im Suchpfad vorhandenen Knoten übereinstimmt, werden Schritte zur Aktualisierung des erreichten Knotens durchgeführt, wobei dieser erreichte Knoten in seinem Positionsfeld den aktuellen Positionszeiger im Eingabedatenspeicher erhält. Dieses Verfahren wird ebenfalls ausgeführt wird, wenn es sich bei dem Internen Knoten nicht um einen Blattknoten handelt und in diesem Fall Schritte zur Erzeugung eines neuen Blattknotens erfolgen, wobei dieser neue Blattknoten in
seinem Positionsfeld den aktuellen Positionszeiger im Eingabedatenspeicher erhält, wobei abschließend ein Hochzählen des Endknotenzählers erfolgt. Wenn die Suche im Trie-Wörterbuchspeicher höherer Ordnung keinen Internen Knoten feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO übereinstimmt, wird ein neuer Blattknoten in diesem Wörterbuch erzeugt, wobei dieser neue Blattknoten die maximale Länge erhält. Abschließend erfolgt dann ein Hochzählen des Endknotenzählers. Das Verfahren wird auch ausgeführt, wenn das Eingabezeichen am Ausgang des Input-FIFO nicht im Literal-Wörterbuch enthalten ist, wobei das Verfahren die Schritte zur Aktualisierung des Literal- Wörterbuches beinhaltet, indem dem Eintrag, der dem Eingangssymbol entspricht, die Anzahl der bisher in diesem Block empfangenen neuen Symbole zugewiesen wird. Schließlich wird der Zähler für die bekannten Symbole um eins erhöht.
Eine Ausbildungsform des Verfahrens sieht vor, daß zur Decodierung des ursprünglichen Datenblocks aus einem codierten Block von Codeworten die in Bytes ausgerichteten Codeworte in den Input-FIFO eingetragen werden, daß der Input-FIFO diese byteausgerichteten Codeworte fester Länge in solche variabler Länge rückkonvertiert und diese als Eingangsgröße für den Decodierungsschritt zur Verfügung stellt, indem diese Codeworte auf der Grundlage des in dem betreffenden Codewort enthaltenen dynamischen Präfixes einem Neuen Literal, einem Bekannten Literal, einem Internen Knoten oder einem Blattknoten zugeordnet werden. Dieses Verfahren wird ausgeführt, wenn das Codewort als Neues Literal erkannt wird und ein einzelnes Symbol im Codewort vorhanden ist, das direkt dem Output-FIFO zugeleitet wird, oder wenn das Codewort als Bekanntes Literal erkannt wird und ein einzelnes Symbol vom Codewort über das Literal-Wörterbuch rückübersetzt und dem Output-FIFO zugeleitet wird, oder wenn das Codewort vom Typ her entweder ein Interner Knoten oder ein Blattknoten im Trie-Wörterbuchspeicher ist. Dabei liest das Verfahren aus dem Trie- Wörterbuchspeicher den Vater-Knoten des betreffenden Internen Knotens, um die frühere Blockposition zu bestimmen, an der eine ähnliche Zeichenkette im Output- FIFO existiert sowie die Knotentiefe an den Decoder zurückliefert, der die Anzahl der für die Darstellung der relativen Länge benötigten Bits und den eigentlichen relativen Wert selbst berechnet. Die Berechnung erfolgt, indem diese relative Länge zum vorbezeichneten Vater-Knoten des Internen Knotens addiert wird, und auf diese Weise die Parameter für die Durchführung der/des stattfindenden Kopier-Schritte(s) für mehrere Zeichen ermittelt werden. Dieser Kopiervorgang enthält alle Schritte, um von der Position, die durch das Positionsfeld dieses decodierten Internen Knotens beschrieben wird, so viele Symbole in den Output- FIFO zu kopieren, wie durch die vorbezeichnete absolute Länge der Kopie bestimmt ist. Dabei werden alle diese Schritte wiederholt, bis keine weiteren Codeworte zu decodieren sind und auf diese Weise der ursprüngliche Symbolblock aus dem komprimierten Block von Codeworten wiederhergestellt wird.
Es ist aber auch möglich, die dynamischen Wörterbücher sowohl für den Trie- Wörterbuchspeicher als auch für das Literal-Wörterbuch bei der Dekompression zu nutzen, wobei zusätzliche Schritte zur Aktualisierung des Trie- Wörterbuchspeichers und des Literal-Wörterbuchs enthalten sind.
Wenn ein Codewort extrahiert wird, das einem Einzelzeichen entspricht, das in den Output-FIFO übertragen werden soll, wird der Trie-Wörterbuchspeicher höherer Ordnung durch Bildung eines neuen Blattknoten aktualisiert. Dieser neue Blattknoten erhält in seinem Positionsfeld den aktuellen Positionszeiger im Output-FIFO und im Feld Zählerwert die maximale Länge. Abschließend erfolgt ein Hochzählen des Endknotenzählers. Gleichzeitig wird festgestellt, ob das decodierte Symbol nicht bereits im Literal-Wörterbuch enthalten ist. In diesem Fall wird zusätzlich ein Aktualisierungsschritt im Literal-Wörterbuch durchgeführt, bei dem dem Symbol an seiner zugehörigen Adresse die Zahl der bisher im Block neu empfangenen Zeichen entsprechend dem aktuellen Zählerwert zugewiesen wird. Schließlich wird dieser Zähler um eins erhöht.
Wenn ein Codewort extrahiert wird, das einem Internen Knoten im Trie- Wörterbuchspeicher entspricht, aber die absolute Längenübereinstimmung, berechnet aus der Summe der Länge dieses Codewortes und der Tiefe des Vater- Knotens, nicht mit der Knotentiefe dieses Knotens selbst übereinstimmt, wird der Trie-Wörterbuchspeicher durch Bildung eines neuen Blattknotens aktualisiert, wobei dieser neue Blattknoten in seinem Positionsfeld den aktuellen Positionszeiger im Eingabedatenspeicher erhält. Abschließend erfolgt ein Hochzählen des Endknotenzählers. Es wird ein neuer Internen Knoten gebildet, wobei dieser neue Interne Knoten in seinem Positionsfeld den aktuellen Positionszeiger im Output-FIFO erhält. Diesem neuen Internen Knoten wird als Tiefe die absolute Übereinstimmungslänge der Zeichenkette zugewiesen, die beim Decodierungsprozeß berechnet wurde. Abschließend erfolgt ein Herunterzählen des Zählers für die Zahl der Internen Knoten um eins.
Wenn ein Codewort extrahiert wird, das einem Internen Knoten im Trie- Wörterbuchspeicher entspricht und die absolute Längenübereinstimmung, berechnet aus der Summe der Länge dieses Codewortes und der Tiefe des Vater- Knotens, mit der Knotentiefe dieses Knotens selbst übereinstimmt, wird der Trie- Wörterbuchspeicher durch Bildung eines neuen Blattknotens aktualisiert, wobei dieser neue Blattknoten in seinem Positionsfeld den aktuellen Positionszeiger im Output-FIFO erhält. Abschließend erfolgt ein Hochzählen des Endknotenzählers.
Es gibt verschiedene Ausbildungsformen des Verfahrens hinsichtlich der Aktualisierung der Präfixe. Unter Verwendung dynamischer Präfixe können sowohl während der Kompression als auch während der Dekompression die Präfixe der Codewort-Typen aktualisiert werden. Die Präfixe können aktualisiert werden, sobald irgendeiner der zu den Elementen der Paare [Bekanntes Literal, Blattknoten] und [Neues Literal, Interner Knoten] gehörenden Zähler größer wird als der Zählerstand des anderen Elementes des Paares und dieses größere Element nun die kürzere für das Paar zur Verfügung stehende Codierung erhält und dieses Element nun mit dem größten Element des anderen Paares verglichen und wiederum dem größten Element die kürzere Codierung zugewiesen wird, wodurch der Präfix-Baum sich selbst ausbalanciert, um das kürzere Präfix dem häufiger aufgetretenen Codewort-Typ zuzuweisen.
Es ist aber auch möglich, die Initialwerte für die Präfixe Neues Literal => 0 (1 Bit), Bekanntes Literal => 10 (2 Bits), Blattknoten => 110 (3 Bits) und Interner Knoten => 111 (3 Bits)
zu definieren, wobei diese Präfixe während des Kompressions- und Dekompressionsvorgangs dynamisch modifiziert werden, oder die Initialwerte für die Präfixe im statischen Fall wie folgt zu definieren: Neues Literal => 110 (3 Bits), Bekanntes Literal => 0 (1 Bit), Blattknoten => 10 (2 Bits, Interner Knoten => 111 (3 Bits).
Das erfindungsgemäße Blockdatenkompressionssystem beinhaltet zwei Wörterbücher. Das erste ist ein präfixfreier Trie-Wörterbuchspeicher, in dem Interne Knoten NODE sowie Blattknoten LEAF enthalten sind. Bei dem zweiten Wörterbuch handelt es sich um ein Literal-Wörterbuch, das die einzelnen Symbole verarbeitet, die durch Einsatz des ersten Wörterbuchs nicht codiert wurden. Während des Kompressionsvorgangs wird eine Suche in einer "Zero Finder Look-Up Table" durchgeführt um festzustellen, die aktuelle Teilzeichen kette im lokalen Eingangs-FIFO mit einem der vorhandenen Zweige des Trie-Wörterbuchspeichers übereinstimmt. Falls dann durch Multi-Byte-Lesen und spekulatives Aktualisieren eine Übereinstimmung gefunden wird, wird der Zweig nach unten verfolgt. Dies erfolgt mit Hilfe eines parallelen Multi-Byte- Vergleichsmoduls. Hierbei werden alle mit der Zeichenkette übereinstimmenden Internen Knoten NODE untersucht bis hin zu dem Blatt, das der maximal erlaubten Zeichenzahl für die Ermittlung der Übereinstimmung entspricht.
Wenn im Gegensatz dazu keine Übereinstimmung im Trie-Wörterbuchspeicher gefunden wird, wird das Ergebnis übertragen, das vom Literal-Wörterbuch geliefert wird. Hierbei kann es sich um das Literal selbst handeln, sofern es im Literal-Wörterbuch noch nicht enthalten ist oder um den von diesem Literal- Wörterbuch gelieferten Code, wenn es bereits zuvor innerhalb des Blocks detektiert wurde. Auf diese Weise wird die Verschlüsselung von Datenströmen mit reduziertem Alphabet optimiert.
Als Ergebnis werden von dieser Datenkompressions-Modellierungseinheit vier Typen von Codeworten generiert. Das Codewort Neues Literal NLIT enthält Zeichen, die im bisherigen Datenstrom nicht vorkommen, das Codewort Bekanntes Literal KLIT enthält Zeichen, die bereits im bisherigen Eingangs- Datenstrom vorgekommen sind, jedoch keine Übereinstimmungen innerhalb der Zweige des Trie-Wörterbuchspeichers erzeugen, der Interne Knoten NODE enthält eine Referenz auf die übereinstimmenden Teilzeichenketten, die an einem internen Zweigknoten des Trie-Wörterbuchspeichers enden und der Blattknoten LEAF enthält eine Referenz auf die übereinstimmenden Teilzeichenketten, die an einem Blattknoten eines Zweiges des Trie-Wörterbuchspeichers enden.
Diese Codeworte werden sodann mit Hilfe eines selbstbalancierenden Präfix- Baumes mit einem veränderlichen Präfix versehen. Codeworte mit dem häufigsten Auftreten erhalten dabei die höhere Priorität, so daß eine höhere Übereinstimmung mit dem Lernprozeß substitutiver Verfahren erzielt wird. Gleichzeitig werden während der ersten Phasen der Kompression kleinere Codeworte erreicht. Das Verfahren liefert generell eine bessere Adaptierbarkeit an unterschiedliche Datentypen für die limitierte Größe der Blockkompression. Die Codierungseinheit der Datenkompressionseinrichtung arbeitet nach dem Pipelineprinzip und ist dann aktiv, wenn die Modellierungseinheit ihre
Wörterbücher abschließend aktualisiert. Die Codierungseinheit transformiert nahezu optimal die erhaltenen Wörterbuchinformationen durch Anwendung relativer, veränderlicher Codedarstellungen, die sich aus aktuellen Status der Wörterbücher ergeben. Dabei wird am Ausgang ein Codewort variabler Länge erzeugt.
Die Ausrichtungseinheit der Kompressionseinrichtung ist ebenfalls entsprechend einer Pipeline strukturiert und arbeitet parallel zur Modellierungs- und Codierungseinheit. Sie verwendet ein Hochgeschwindigkeitsverfahren zur Ausrichtung der vom Codierer gelieferten Codeworte variabler Länge an die für die endgültige Ausgabe erforderlichen Bytegrenzen.
Die Endergebnisse der Kompression werden vorübergehend in einem First-in-first- out- (FIFO) Speicher abgelegt, der eine dem jeweiligen angeschlossenen Bus entsprechende Datenübertragung zum externen Speicher gestattet und die von der Anordnung geforderte Spitzenbandbreite minimiert.
Das Blockdatenkompressionssystem wird nachstehend an einem Ausführungsbeispiel näher erläutert. Die dazugehörige Zeichnung zeigt in
Fig. 1 ein Blockschaltbild einer Kompressionseinheit,
Fig. 2 Datenstrukturen, die in der bevorzugten Realisierung der vorliegenden Erfindung im Trie-Wörterbuchspeicher 4 implementiert sind,
Fig. 3 einen selbstbalancierenden Präfix-Baum für die Vergabe von
Präfixen für die Ausgabeeinheiten, der in der bevorzugten Realisierung der vorliegenden Erfindung implementiert ist,
Fig. 4 ein Blockschaltbild einer Dekompressionseinheit.
Fig. 5 ein Ausführungsbeispiel für das Kompressionsverfahren für eine
Eingabezeichenkette
Fig. 6 Trie-Suffix-Baum nach Figur 5.
Gegenstand der Erfindung sind ein Blockdatenkompressionssystem und ein Verfahren zur schnellen Blockdatenkompression mit Multi-Byte-Suche. Die Einrichtung und die bevorzugte Realisierung der Erfindung ist im Blockschaltbild, Figur 1 , dargestellt. Figur 1 zeigt auch die Mittel zur Realisierung der Erfindung auf, die durch jegliche Hardware-Implementierungen, von der diskreten IC-Anwendung, FPGA-Technologien sowie alle digitalen Entwurfstechnologien auf der Basis von ASIC's möglich ist.
Eine Kompressionseinheit 1 besteht aus einem Trie-Wörterbuchspeicher 4, der ein Wörterbuch höherer Ordnung enthält, sowie einem Literal-Wörterbuch 2. Die Kompressionseinheit 1 kann prinzipiell vom Trie-Wörterbuchspeicher 4 getrennt werden. Bei der erfindungsgemäßen Lösung sind diese jedoch zu einer einzigen Lösung zusammengefaßt. Damit werden die Vorteile der Verwendung einer
direkten Speicherschnittstelle 103 für den sofortigen Zugriff auf lange Speicherdatensätze ausgenutzt. Der Zugriff auf den Trie-Wörterbuchspeicher 4 erfolgt über die Speicherschnittstelle 103, über die alle elektrischen und zeitsteuerungsspezifischen Signale des Trie-Wörterbuchspeichers 4 übertragen werden. Während der Trie-Wörterbuchspeicher 4 in der umfassenden Ausführung der vorliegenden Erfindung als RAM ausgeführt ist, können bei speziellen Realisierungen auch ROM-Lösungen zum Einsatz gelangen. In diesem Fall müssen die ROM-Wörterbücher im voraus erstellt und vorprogrammiert werden.
Eine ausführliche Beschreibung der im Trie-Wörterbuchspeicher 4 verwendeten Datenstruktur ist in Figur 2 dargestellt. Jede Eingabe in den Trie- Wörterbuchspeicher 4 ist in Form eines langen Datensatzes organisiert. Jeder Datensatz enthält die folgenden Felder: Vater 210 (12-bits), Position 211 (12-bits), Zählerwert 212 (8-bits), Neu 213 (8-bits), Knoten 214 (12-bits). In Klammern ist beispielhaft die in der bevorzugten Ausführung verwendete Anzahl der Bits pro Feld angegeben, die für die maximale interne Blockgröße von 4 kByte gelten. Die Anzahl der erforderlichen Bits verändert sich dabei proportional zur Vergrößerung oder Verkleinerung der Blockgröße.
Ein weiteres Funktionsmerkmal des Trie-Wörterbuchspeichers 4 besteht darin, daß er zum gleichen Zeitpunkt sowohl Interne Knoten NODE als auch Blattknoten LEAF enthält. Dabei werden die Internen Knoten NODE von 1 ab inkrementiert gezählt, während die Knoten vom Typ Blattknoten LEAF vom Maximalwert (OxOfff für eine Blockgröße von 4 kByte) an dekrementiert gezählt werden. Die Konstruktionsregeln, die bei der Erzeugung und Aktualisierung des Trie- Wörterbuchspeichers 4 zur Anwendung gelangen, verhindern jede Kollision zwischen diesen beiden Knotentypen. Gleichzeitig besitzt diese Konstruktion erhebliche Vorteile in Bezug auf Speicherbedarf im Vergleich zu früheren Lösungen.
Jeder Datensatz, der im Trie-Wörterbuchspeicher 4 enthalten ist, besitzt eine Beschreibung für die gespeicherten Felder, die wie folgt aussieht, dargestellt in Figur 2: Das Feld Position 211 enthält die Adresse des Anfangspunktes der Zeichenkette, die vom Knoten beschrieben wird, im ursprünglichen Eingabeblock. Das Feld Vater 210 bezeichnet entweder den vorhergehenden Knoten eines spezifischen Knotens des Trie-Wörterbuchspeichers 4 in der Top-Down-Suche, sofern dieser existiert, bzw. das erste Symbol der Teilzeichenkette, die dieser spezifische Knoten repräsentiert (z.B. 'a' bei Zeichenkette 'abcd'). Die Unterscheidung erfolgt über ein Flag im höchstwertigen Bit. Das Feld Neu 213 enthält das Symbol, das den Weg vom Vater-Knoten zu dem spezifischen Knoten angibt (z.B. NEU- c' für den Übergang vom 'ab' repräsentierenden Knoten zu dem Knoten, der 'abc' repräsentiert). Das Feld Zählerwert 212 gibt die Übereinstimmungstiefe der Symbolstrings an, die den jeweiligen Knoten erzeugen. Das Feld Knoten 214 gibt die Nummer des Knotens innerhalb des Trie- Wörterbuchspeichers 4 an.
Der Datenfluß, der während der Kompression im System entsteht, ist in Figur 1 dargestellt und wird im folgenden beschrieben. Zuerst wird der Inhalt des I/O-Memory-Busses 113 in den Input-FIFO 8 eingelesen, der bei der bevorzugten Ausführung in der Lage ist, mindestens 64 Byte zu speichern. Danach werden die
beiden nächsten auszugebenden Symbole im Input-FIFO 8 benutzt, um eine Hash-Funktion zu erzeugen, die als Ergebnis eine Adresse sowohl für die Zero- Finder-Lookup-Tabelle 3 als auch den Trie-Wörterbuchspeicher 4 erzeugt. Diese Adresse wird verwendet um festzustellen, ob ein Knoten im Trie- Wörterbuchspeicher 4 existiert, der eine Zeichenkette mit ähnlichen Startsymbolen wie die derzeit analysierte Zeichenkette repräsentieren könnte. Wenn das aus der Zero-Finder-Lookup-Tabelle 3 mittels des ZeroFinder-LUT- Busses 102 gelesene Bit anzeigt, daß diese Adresse nicht leer ist, wird von der Modellierungseinheit 6 ein Schreib-Lese-Vorgang auf die spezifische, durch die Hash-Funktion berechnete Adresse mittels der Speicherschnittstelle 103 gestartet. Als Ergebnis dieses Schreib-Lese-Vorgangs wird die Hash-Gültigkeit bestätigt, wobei zum selben Zeitpunkt die im Feld Knoten 214 gespeicherte Knotennummer und alle damit zusammenhängenden Informationen gelesen werden. Diese gelesene Information enthält Angaben bezüglich des früheren Vorkommens der zuletzt gespeicherten Symbolkette, die dasselbe Anfangspaar von Symbolen enthält, sowie die Tiefe der zuvor gefundenen Übereinstimmung (in Feld Zählerwert 212).
Wenn die Hash-Gültigkeit auf Grund der Übereinstimmung des Feldes Vater 210 und des Feldes Neu 213 mit dem ersten bzw. zweiten Zeichen des Anfangspaares bestätigt ist, wird ein Lese-Vergleichs-Zyklus gestartet. Dazu wird die Vergleichseinheit 5 über den FIFO-Vergleichs-Bus 108 mit den Symbolen, die auf das geprüfte Paar im Input-FIFO 8 folgen, geladen. Diese werden mit den über den Puffer-Vergleichs-Bus 109 aus dem Blockpuffer 10 gelesenen Daten verglichen, wobei die Übertragung ab der durch den Inhalt des Positionsfeldes 211 abgeleiteten Adresse beginnt.
In der als bevorzugte Ausführung beschriebenen Einrichtung werden in der Vergleichseinheit 5 gleichzeitig 4 Byte verglichen, so daß durch Wiederholung der Vergleichsoperation und Übertragung der Ergebnisse über den Ergebnisvergleichsbus 104 zur Modellierungseinheit 6 übereinstimmende Zeichenketten in kurzer Zeit bestimmt werden können. Dieser Vergleich wird solange durchgeführt, bis eine Nichtübereinstimmung gefunden wird oder die im Feld Zählerwert 212 definierte Vergleichstiefe erreicht ist. Als Ergebnis dieses Prozesses enthält die Modellierungseinheit 6 die maximale Übereinstimmungslänge der aktuellen Symbolzeichenkette im oberen Bereich des Input-FIFO-Blockes 8 mit den vorhandenen Wörterbucheintragungen. Nunmehr sendet die Modellierungseinheit 6 ein Paar [relativer Knoten, relative Verschiebung] zur Codierungseinheit 7. Der "relative Knoten" wird aus der Differenz zwischen dem letzten im Wörterbuch bestimmten Knoten und dem durch das Feld Knoten 214 bestimmten abgeleitet. Auf ähnliche Weise wird die relative Verschiebung als Differenz zwischen aktueller Übereinstimmungstiefe und der Tiefe des Vater-Knotens berechnet.
Wenn während der oben beschriebenen Prozedur keine Übereinstimmung entweder zwischen dem Feld Vater 210 oder dem Feld Neu 213 des untersuchten Knotens mit den aktuellen Registerwerten gefunden wird ("Hash-Prüfung"), erzeugt die Modellierungseinheit 6 eine neue Hash-Adresse, wiederholt mit dieser Adresse die Suche im Trie-Wörterbuchspeicher 4 oder beendet sie. Zur Ermittlung der genannten neuen Hash-Adresse dient der Inhalt der Zero-Finder-Lookup-
Tabelle 3. Sobald aus der Zero-Finder-Lookup-Tabelle 3 zu erkennen ist, daß für die erste Hash-Adresse der ersten beiden Zeichen im Input-FIFO 8 kein Knoten im Trie-Wörterbuchspeicher 4 vorhanden ist, wird ein Literal-Codiertyp verwendet. Das erste Zeichen wird dann verwendet, um das Literal-Wörterbuch 2 über den Literal-Bus 101 zu adressieren, wobei aus den über den Literal-Bus 101 zurückgelesenen Daten erkannt wird, ob das erste Symbol im Input-FIFO 8 im bisher verarbeiteten Datenstrom schon vorkam. Falls die Antwort vom Literal- Wörterbuch 2 positiv ausfällt (gekennzeichnet durch eine Eins im höchstwertigen Bit der Antwort), wird die Literalcodierung, die dem betreffenden Symbol bei seinem ersten Auftreten zugewiesen wurde, gleichzeitig über den Literal-Bus 101 empfangen. Durch Zuweisung einer variablen Anzahl von Bits für die Literalcodierung der einzelnen Zeichen verkürzt sich ihre Codierung im Vergleich zu dem Fall, in dem sie in ihrer ursprünglichen Form zum Ausgang übertragen werden. Dabei ist die Anzahl der Bits proportional zur Alphabetgröße des codierten Datenstroms.
Wenn für das spezifische Literal vom Literal-Wörterbuch 2 über den Literal-Bus 101 eine Null im höchstwertigen Bit (MSB) zurückliefert wird, bedeutet dies, daß das Literal noch nicht im verarbeiteten Block vorhanden war. Das betreffende Literal wird sodann in seiner ursprünglichen Form zur Codierungseinheit 7 übertragen. In diesem Fall wird das Literal-Wörterbuch 2 während des über den Literal-Bus 101 ablaufenden Schreib-Lese-Zyklusses aktualisiert, wobei dem betreffenden Zeichen die entsprechende Codierung für "Bekanntes Literal KLIT" zugeteilt und das höchstwertige Bit (MSB) auf den Wert eins gesetzt wird. Danach wird die Codierung für "Bekanntes Literal KLIT" um eins erhöht.
Als Ergebnis der oben geschilderten Operationen können vier Codetypen von der Modellierungseinheit 6 generiert und zur Codierungseinheit 7 übertragen werden: Neues Literal NLIT, Bekanntes Literal KLIT, Interner Knoten NODE, Blattknoten LEAF.
Die ersten beiden Codierungstypen entsprechen einer Einzelzeichen-Codierung, während die letzten beiden Typen einer Mehrzeichen-Codierung, ausgedrückt durch den Inhalt des Trie-Wörterbuchspeichers 4, entsprechen. Da die Anzahl der von der Modellierungseinheit 6 erzeugten Einheiten größer ist als bei allen früheren Lösungen, sind traditionelle Markierungsverfahren nutzlos. Weiterhin müssen besondere Maßnahmen in Betracht gezogen werden, um die Präfixlänge optimal zu halten.
Figur 3 zeigt den selbstbalancierenden Präfix-Baum, der für den dynamischen Präfix-Aufbau verwendet wird. Die Präfixe sind in zwei Gruppen (I und II) unterteilt, wobei zur Knotengruppe I (302) die NLIT-Codierung im NLIT-Knoten-Zähler 304 und die LEAF-Codierung im LEAF-Knoten-Zähler 305 gehören und zur Knotengruppe II (303) die KLIT-Codierung im KLIT-Knoten-Zähler 306 und die NODE-Codierung im NODE-Knoten-Zähler 307. Jeder Codierungstyp besitzt einen Aufwärtszähler, wobei zu Beginn der Kompression des Datenblocks alle Zähler auf Null gesetzt werden.
Figur 3a zeigt zusätzlich eine vordefinierte Start-Codierung für jeden Codierungstyp, wobei NLIT den kürzesten Code (1 Bit) [0] aufweist, gefolgt von
KLIT (2 Bit) [10] sowie von LEAF und NODE mit jeweils 3 Bit [110 bzw. 111]. Während des Kompressionsvorganges wird für jeden neu codierten und zur Codierungseinheit übertragenen Codetyp das entsprechende Präfix aus dem Baum zur Markierung dieses Codewortes ausgewählt. Danach wird der Baum aktualisiert. Während dieses Aktualisierungsprozesses wird der entsprechende Zähler erhöht und der Zählerstand mit dem anderen in der Gruppe befindlichen verglichen. Sobald die Zählerstände im LEAF-Knoten-Zähler 305 bzw. im NODE- Knoten-Zähler 307 in Figur 3a größer werden als die Zählerstände im NLIT- Knoten-Zähler 304 bzw. KLIT-Knoten-Zähler 306 für die linken Gruppenmitglieder, wird der entsprechende Codetyp zum Führer der Gruppe und erhält das Präfix seines Paares in der entsprechenden Gruppe. Der Führer der Gruppe wird nun auf Gruppen-Level verglichen. Auch auf diesem Niveau gelten für die Ermittlung des kürzesten Codes (1-Bit), der der Gruppe, die den höchsten Zählerstand besitzt, zugeteilt wird, dieselben Regeln. Der Führer der anderen Gruppe erhält die zweitkürzeste Codierung (2 Bit).
Ein besseres Verständnis für das Verfahren läßt sich mit Hilfe des ergänzenden Diagramms in Figur 3b erreichen. Hier erhält jeder Codetyp einen Quadranten innerhalb eines im Uhrzeigersinn gedrehten Prioritätenkreises 308 zugeordnet. Weil zu Beginn eines Datenblocks die Wahrscheinlichkeit, ein Neues Literal NLIT zu finden, weitaus höher ist, als die Wahrscheinlichkeit, irgendeinen anderen Codetyp zu finden (für das erste Symbol 100 %), erhält NLIT das kürzeste Präfix und wird dem Quadranten mit der höchsten Priorität zugewiesen. Sobald sich das Alphabet am Eingang beginnt zu wiederholen (noch nicht jedoch die Symbolpaare des Trie-Wörterbuchspeichers 4 auftreten), bewegen sich die Codetypen im Uhrzeigersinn, d.h. KLIT befindet sich nun im Quadranten mit der höchsten Wertigkeit.
In der Zwischenzeit füllt sich der Trie-Wörterbuchspeicher 4 immer mehr. Sobald die Anzahl gefundener Blätter größer wird als der Inhalt des KLIT-Knoten-Zählers 306, dreht sich der Kreis erneut, wodurch dem Auftreten eines Blattknotens LEAF als nächstes Codewort die höchste Wertigkeit zugeteilt wird. Dies setzt sich bis zu dem Punkt fort, an dem der Wörterbuchspeicher 4, sobald die Daten ausreichend homogen sind, in der Lage ist, auf Grund der Homogenität der Daten den größten Teil der Eingangsdaten mit Hilfe der Internen Knoten NODE auszudrücken. Nun erhält das entsprechende Präfix die kürzeste Anzahl von Bits.
Figur 3b dient lediglich zur Verdeutlichung; das reale Verhalten des Systems aus Figur 3a unterscheidet sich von dem oben beschriebenen Verhalten in gewisser Weise. Es ist jedoch zum besseren Verständnis des zugrundeliegenden Verfahrens hilfreich.
Der Vorteil dieses Verfahrens gegenüber früheren Lösungen besteht darin, daß relativ hohe Kompressionsraten für sehr kleine Blöcke bzw. schon für den Anfang größerer Datenblöcke erzielt werden können. Während bislang der Kompressionsprozess unter der Prämisse zuvor gefüllter Wörterbücher erläutert wurde, konzentriert sich jetzt die Beschreibung auf den Aktualisierungsprozess der Wörterbücher, der im Falle eines selbstadaptierenden, dynamischen Ablaufs unter Verwendung der Schreib-Lese-Speicher stattfindet, wie dies in der bevorzugten Ausführung der Fall ist.
Entsprechend dem in Figur.1 dargestellten und für die Kompression typischen Datenfluß wird der Trie-Wörterbuchspeicher 4 als Teil der Kompressionsschritte durch die Modellierungseinheit 6 aktualisiert, um den Änderungen Rechnung zu tragen, die durch das verarbeitete Zeichen bzw. die verarbeitete Zeichenkette bewirkt wurden. Zunächst wird in jedem Fall ein neuer Blattknoten LEAF erzeugt. Dieser repräsentiert die spezifische Zeichenkette, die mit den Zeichen am Ausgang des Input-FIFO 8 beginnt. Daraufhin wird der Blatt-Knotenzähler um eins erniedrigt.
Wenn der Codierungstyp als Literal ermittelt wurde, dann ist der Vater-Knoten dieses neuen Blatts das Originalsymbol selbst. Wenn im Gegensatz dazu ein Zweig innerhalb des Trie-Wörterbuchspeichers 4 für mindestens zwei Zeichen am Ausgang des Input-FIFO 8 gefunden wurde, erhält das Feld Vater 210 des neu zu erzeugenden Blattes die Knotennummer des Knotens im Trie-Wörterbuchspeicher 4, auf den zuletzt zugegriffen wurde. Wenn zusätzlich während des Suchprozesses bei der schrittweisen Verfolgung eines Zweiges des Trie- Wörterbuchspeichers 4 die Zielknotentiefe nicht erreicht wird, wird ein neuer interner Knoten erzeugt, der den gemeinsamen Teil von mindestens zwei existierenden Zeichenketten im Trie-Wörterbuchspeicher 4 charakterisiert. Der neue Blattknoten LEAF wird als Zweig, der im soeben erzeugten Internen Knoten NODE beginnt, angelegt.
Es sei angemerkt, daß der Aktualisierungsvorgang zur besseren Erklärung zwar aufgeteilt wurde, diese Erfindung aber in der Lage ist, die Aktualisierung im Trie- Wörterbuchspeicher 4 gleichzeitig mit dem Schreib-Lese-Zyklus auf die Adresse des letzten Hash-Kandidaten durchzuführen, die durch die Modellierungseinheit 6 berechnet wird. Da der erste Schreibvorgang erfolgen kann, bevor die Modellierungseinheit 6 endgültige Kenntnis über die Länge der Übereinstimmung besitzt, wird der Knoten, auf den gerade zugegriffen wird, in seinem Feld Position 211 aktualisiert, und ein vorläufiges Blatt wird im voraus angelegt. Dieser geschwindigkeitserhöhende Vorgang wird als Spekulative Voraus-Aktualisierung (ASU) bezeichnet. Dieses vorläufige Blatt wird in der Annahme erzeugt, daß die Suche im Trie-Wörterbuchspeicher 4 erfolglos bleibt und das einzelne aktuelle Zeichen, das durch das Feld Vater 210 adressiert wird, der Vater-Knoten des betreffenden Blattes sein wird. Falls diese Annahme unzutreffend ist, wird für das betreffende Blatt ein erneuter Schreibvorgang ausgelöst, der parallel zur Hinzufügung neuer Zeichen zum Trie-Wörterbuchspeicher 4 erfolgt und damit keine Extra-Zeitscheibe erfordert. Das Ergebnis dieser spekulativen Voraus- Aktualisierung ist ein reduziertes und ausbalanciertes Zustandsdiagramm für die Modellierungseinheit 6. Das führt für die bevorzugte Ausführung dieser Erfindung zu einer Leistungssteigerung.
Eine ähnliche spekulative Technik wird parallel zum oben geschilderten Vorgang auch für die Aktualisierung des Literal-Wörterbuches 2 eingesetzt. Wenn ein Neues Literal NLIT als Ergebnis eines Lesevorganges in der Zero-Finder-Lookup- Tabelle 3 in Figur 1 festgestellt wird, wird eine spekulative Aktualisierung des Literal-Wörterbuches 2 durch Schreiben des neu zugewiesenen Indexes für das betreffende Eingangssymbol ausgeführt. Sobald die Modellierungseinheit 6 die Verarbeitung einer bestimmten Teilzeichenkette im Zeichen-Eingangsstrom
abgeschlossen hat, überträgt sie die Codeworte über den Eingangsbus der Codierungseinheit 105 zur Codierungseinheit 7 in Figur 1. Die Aufgabe der Codierungseinheit 7 besteht darin, diese Informationen in einen Bitstrom zu wandeln, der später von der Dekompressionseinheit verstanden werden kann, wobei Bezugnahmen auf den aktuellen Inhalt aller Wörterbücher und Zähler (Blattzähler, Knotenzähler,...), die für den Kompressionsprozeß genutzt werden, enthalten sind, soweit sie ebenfalls synchron durch die Decodierungseinheit generiert werden müssen.
Von der Codierungseinheit 7 durchgeführte Bitoperationen sind überwiegend direkte logische Transformationen, so daß keine Iterationen erforderlich sind, wodurch die Geschwindigkeitsanforderungen des Kompressionsverfahrens erfüllt werden.
Zur Erreichung dieses Ziels wendet die Codierungseinheit 7 die folgenden Regeln an, für deren Umsetzung die entsprechenden Hardware-Implementierungen in der Einrichtung vorhanden sind:
- Wenn ein Blattknoten LEAF zu codieren ist, wird die Blatt-Nummer relativ zum aktuellen Blatt-Zählerstand unter Nutzung eines Tripel-Präfix-Schemas (kurz, mittel, lang) ausgedrückt, wobei die Bitanzahl für jede Stelle entsprechend dem Blattzählerstand anwachsen kann (entsprechend der notwendigen Bitanzahl zur Darstellung der Differenz zwischen dem Startblatt und dem aktuellen Blatt). Die Länge der Symbol- oder Wörterbuchübereinstimmung wird ebenfalls nicht in absoluter Form ausgedrückt, sondern durch Bezugnahme auf den Vater-Knoten dieses Blattknotens. Für diese ganzen Zahlen wird eine Unary-Codierung verwendet, die besonders kurze Codes favorisiert.
- Wenn ein Interner Knoten NODE codiert werden muß, wird die Knoten-Nummer zunächst auf die maximale Anzahl von Bits reduziert, die durch log2 (Knotenzähler) vorgegeben ist, und schließlich modifiziert, wenn innerhalb dieses Codierungsraumes (bestimmt durch die Bit-Länge) nicht alle Codierungsmöglichkeiten genutzt werden ("sparse codes"). Dasselbe Verfahren wird für die Übereinstimmungstiefe im Wörterbuch angewendet, die als Abstand zum Vater-Knoten berechnet wird. Auch hier wird die minimale, potentiell notwendige Bitanzahl zur Erfassung dieses Abstandes verwendet, einschließlich der Berücksichtigung von "Sparse Codes", falls zutreffend.
- Wenn ein Bekanntes Literal KLIT zu übertragen ist, wird anstelle des Codewortes selbst sein Index im Literal-Wörterbuch 2 zur Decodierungseinheit übertragen. Die Länge beträgt log2 (Literal-Zähler), wobei auch hier "Sparse Codes" verwendet werden, wenn dies möglich ist.
- Ein Neues Literal NLIT überträgt immer das Literal in seiner Originaldarstellung.
Als Ergebnis des oben beschriebenen Codierungsverfahrens wird die Codierung variabler Länge über den Eingabebus der Ausrichtungseinheit 107 in die Ausrichtungseinheit 9 in Figur 1 übertragen, während die Codierungseinheit 7 sich selbst für den nächsten von der Modellierungseinheit 6 erzeugten Codierungszyklus freigibt, der parallel zu den vorangegangenen Zyklen bzw. dem vorangegangenen Zyklus ablief, und die nächsten Zeichen im Input-FIFO 8 verarbeitet. Die Funktion der Ausrichtungseinheit 9 besteht darin, die Ketten
codierter Bits in eine an Bytegrenzen ausgerichtete Form umzuwandeln, die vom Output-FIFO 12 verarbeitet werden kann. Zu diesem Zweck enthält die Ausrichtungseinheit 9 eine Vorrichtung zum Anhängen des neuen bitcodierten Datenstroms, der für das spezielle Codewort codiert wurde, an den verbliebenen Teil des vorhergehenden Bitstroms. Dabei werden die Bit-Darstellungen verkettet. Außerdem ist eine weitere Vorrichtung zur schnellen parallelen Verschiebung des neuen Bitstroms um eine bestimmte Anzahl von Bits enthalten. Als Ergebnis dieser Operation erhält man eine unterschiedliche Anzahl von ausgerichteten Bytes und einen Bitrest zur Verarbeitung im nächsten Ausrichtungszyklus.
Diese Ausgabe-Bytes werden dann über den Output-FIFO-Bus 111 zum Output- FIFO 12 übertragen, in dem sie solange gepuffert werden, bis die Ausgabe- Busbreite erreicht ist. Dann wird eine Anforderung (typischerweise eine DMAS- Anforderung) für den Ausgabebus des Output-FIFO 114 generiert. Auf diese Weise wird die Gesamt-Bandbreite des Systems optimiert, in der sich die Datenkompressionseinheit befindet.
Einige Telekommunikationsanwendungen, bei denen kleine Datenfragmente abwechselnd von unterschiedlichen Quellen kommen, jedoch zu unterschiedlichen Kontexten gehören, wie es zum Beispiel bei einem Router zum Handling mehrerer virtueller Kanäle der Fall ist, gelten als spezifische Anwendungsfälle.
Auf Grund der hochgradig synchronen Natur der in dieser Erfindung beschriebenen Kompression und der sich ergebenden Vorteile bezüglich der erreichbaren Kompressionsraten für die Fälle, in denen ein Datenblock ausschließlich aus homogenen Informationen besteht, ist es in der Regel wünschenswert, diese getrennten virtuellen Kanäle als unterschiedliche Kontexte zu verarbeiten, wobei jeder einzelne sein eigenes Wörterbuch besitzt.
Zu diesem Zweck wird in einer optionalen Ausführung der vorliegenden Erfindung zusätzlicher Speicherplatz zur Speicherung der unterschiedlichen Kontexte im Trie-Wörterbuchspeicher 4 über die Speicherschnittstelle 103 vorgesehen. Außerdem enthält sie eine Upload-/Download-Vorrichtung zu/von diesem Speicher zur Übertragung der Registerinhalte aller internen Einheiten und für die Inhalte sämtlicher internen Wörterbücher.
Da der Dekompressionsvorgang das genaue Gegenteil des oben geschilderten Verfahrens darstellt, wird dieser nur in zusammengefaßter Form anhand des in Figur 4 gezeigten Datenflusses behandelt.
Zunächst werden die verschlüsselten Daten in den Input-FIFO 410 über den Eingabebus der Ausrichtungseinheit 508 übertragen. Dieser arbeitet jetzt im Umkehrbetrieb und liest nur so viele Bytes wie erforderlich sind, um ihn gefüllt zu halten. Die im Input-FIFO 410 enthaltenen Daten werden dann zur Ausrichtungseinheit 407 übertragen, in der die korrekte Bit-Bedeutung und Bit- Reihenfolge der repräsentierten Codeworte variabler Länge wiederhergestellt werden. Dies geschieht in engem Zusammenwirken mit der Decodierungseinheit 405, die alle Aufgaben übernimmt, die mit der Ermittlung der Länge aller Datenfragmente im Zusammenhang stehen, die in dem spezifischen Codewort enthalten sind. Dies geschieht mit Hilfe der aktuellen Inhalte der Register, die von
der Decodierungseinheit 405 und der Modellierungseinheit 404 gemeinsam genutzt werden.
Danach prüft die Decoderungseinheit 405 den Status des selbstbalancierenden Präfix-Baumes in Figur 3a um zu ermitteln, welcher Codewort-Typ decodiert werden soll und erfaßt zu diesem Zweck Informationen über Anzahl und Typ der Codewort-Fragmente, die in ihm enthalten sind. Wenn die Decodierungseinheit 405 diese Fragmente entschlüsselt hat, werden die absoluten Werte des ersten Fragments, das auf das Codewort-Präfix folgt, wiederhergestellt. Dieses Fragment kann entweder einen Knoten im Trie-Wörterbuchspeicher 4 (enthalten im Trie- Wörterbuchspeicher 403) repräsentieren, das durch den Decoder symmetrisch wiederhergestellt werden muß, öder es repräsentiert ein Literal-Codewort, das eventuell das symmetrische Literal-Wörterbuch 402 nutzt. Diese Information wird nun zur Modellierungseinheit 404 zurückübertragen, die auf das betreffende Wörterbuch zugreift, um alle noch notwendigen Informationen zu bekommen, die die Decodierungseinheit 405 benötigt, um die Codewort-Entschlüsselung zu beenden. Wenn das entschlüsselte Codewort vom Typ "Literal" ist (KLIT oder NLIT), existiert kein zweites Fragment, und die Modellierungseinheit 404 überträgt das wiederhergestellte Literal sowohl in den Blockpuffer 408 als auch zum Output- FIFO 406, der nun umgekehrt als Zwischenspeicher für den Entschlüsselungsprozess dient. Wenn im Gegensatz dazu ein Codewort von Typ "NODE" (NODE oder LEAF) erkannt wird, existiert ein zweites Fragment, das die Verschiebung bezüglich des Vater-Knotens im Trie-Wörterbuchspeicher 403 kennzeichnet. Die Decodierungseinheit 405 verarbeitet die Informationen über die Knotentiefe des spezifischen Knotens, die über den Ausgangsbus der Decodierungseinheit 504 von der Modellierungseinheit 404 geliefert wird, und die Verschiebung, die aus dem Codewort gewonnen wird, das über den Bus 505 von der Ausrichtungseinheit 407 kommt, um die absolute Tiefe im Zweig zu erhalten. Sie ist ein Maß für die Länge der übereinstimmenden Zeichenkette. Diese Tiefe im Trie-Wörterbuchspeicher 403 wird über den Bus 504 zurück zur Modellierungseinheit 404 übertragen. Die Modellierungseinheit 404 führt sodann einen Multi-Byte-Kopiervorgang (beginnend mit der Position in der Zeichenkette, die durch den Knoten des Trie-Wörterbuchspeichers 403 gekennzeichnet wird) vom Block-Buffer 408 in das Output-FIFO 406 durch. Gleichzeitig markiert sie diese neuen Symbole zum Rückschreiben aus dem Output-FIFO 406 zur neuen Position innerhalb des Block-Buffers 408 im nächsten freien Zyklus bzw. den nächsten freien Zyklen. Wie während des Kompressionsvorgangs übernimmt der Output-FIFO 406 die Aufgabe, die Ausgabesymbole für eine Schreib-Operation in den externen E/A-Speicher entsprechend der Busbreite aneinanderzureihen, die Schreiboperation zu initialisieren und auszuführen. Dazu wird normalerweise ein DMA-Handshake-Protokoll genutzt, um ein optimales Timing-Inten/all zur Minimierung der Bandbreite zu erhalten, die für diesen externen Speicher erforderlich ist.
Zusammenfassend sei das Blockdatenkompressionssystem, bestehend aus einer Kompressionseinrichtung und einer Dekompressionseinrichtung nochmals dargestellt. Die Kompressionseinrichtung enthält einen Input-FIFO 8, um Eingangssymbole nach dem First-in-first-out Prinzip zu puffern. Dieser Input FIFO 8 ist mit einer Steuerungskomponente und einer Modellierungseinheit 6 verbunden, wobei diese Modellierungseinheit 6 mit einem Trie-
Wörterbuchspeicher 4, einer Zero-Finder-Lookup-Tabelle 3, Suchkomponenten in Form einer Vergleichseinheit 5, Speicherkomponenten in Form eines Literal- Wörterbuches 2 und einer Codierungseinheit 7 verbunden ist. Die Codierungseinheit 7 ist wiederum über eine Ausrichtungseinheit 9 mit einem Output-FIFO 12 verbunden. Der Trie-Wörterbuchspeicher 4 besteht aus einer Vielzahl von Speicherstellen, wobei die Modellierungseinheit 6 parallel auf diesen zugreift, und das Wörterbuch höherer Ordnung bildet, das durch eine Hash- Funktion adressiert wird, die aus den ersten Zeichen, die im Input-FIFO 8 enthalten sind, berechnet wird. Die Zero-Finder-Lookup-Tabelle 3 dient zur Vorausbestimmung ungenutzten Platzes im Wörterbuch höherer Ordnung, wobei die Modellierungseinheit 6 auf das Wörterbuch höherer Ordnung zugreift, um zu bestimmen, ob die im Input FIFO 8 enthaltene Zeichenkette durch einen beliebigen inneren oder externen Knoten, der in diesem Wörterbuch existiert, ersetzt werden kann. Die Vergleichseinheit 5 führt dabei den parallelen Vergleich mehrerer Zeichen durch, um die maximale Länge der Übereinstimmung zwischen dem betreffenden Knoten in diesem Wörterbuch und der Zeichenkette im Input- FIFO 8 zu bestimmen. Das Literal-Wörterbuch 2 bildet das Wörterbuch niedriger Ordnung, wobei der Inhalt des Literal-Wörterbuches 2 zur Erzeugung der codierten Form für Zeichenketten der Länge 1 in der Modellierungseinheit 6 genutzt wird. Die Modellierungseinheit 6 bestimmt, ob das Ergebnis der parallelen Suche in der Vergleichseinheit 5 oder der Inhalt des Literal-Wörterbuches 2 als Ausgangsgröße der Modellierungseinheit 6 gewählt wird. Die Modellierungseinheit 6 führt sowohl eine iterative parallele Suche durch, wenn ein oder mehrere im Trie-Wörterbuchspeicher 4 enthaltene Knoten die Übereinstimmungslänge mit der im Input-FIFO 8 befindlichen Zeichenkette erhöhen, als auch ein Pipelining der Ergebnisse zur Codierungseinheit 7, die kompakte Ausgangscodeworte variabler Länge erzeugt, die eine relative Darstellung der Ausgangswerte der Modellierungseinheit 6 verwendet, wobei die Ausgangscodeworte vom aktuellen Zustand der Codierungseinheit 7 abhängig sind. Die Codierungseinheit 7 enthält Komponenten zum Pipelining dieses Ausgangscodewortes variabler Länge zur Ausrichtungseinheit 9, die das Ausgangscodewort variabler Länge in ein an Bytegrenzen ausgerichtetes Codewort umwandelt. Der Output-FIFO 12 enthält Komponenten zur temporären Speicherung dieser an Bytegrenzen ausgerichteten Codeworte, bis die spezifizierte Breite des Ausgangsbusses erreicht wird und ein geeigneter Ausgabezeitpunkt vorliegt, um auf diese Weise einen Block von nichtkomprimierten digitalen Eingabedaten mit Hilfe des Kompressionsprozesses in einen komprimierten Datenstrom zur Ausgabe über den Ausgabebus 114 des Output-FIFO 12 umzuwandeln.
Nach einer Ausbildung der Erfindung enthält die Modellierungseinheit 6 Aktualisierungskomponenten zur Einfügung sowohl der vorläufigen als auch der endgültigen Informationen in das Wörterbuch höherer Ordnung, die bewirken, daß die aktuelle Zeichenkette am Ausgang des Input-FIFO 8 den aktuellen Status des Trie-Wörterbuchspeichers 4, der das Wörterbuch höherer Ordnung enthält, beeinflußt, wobei die vorläufige Information den Kompressionsprozeß für den Fall beschleunigt, daß das endgültige Update mit dem vorläufigen Update identisch ist und demzufolge dieses endgültige Update vermieden wird.
Es ist aber auch möglich, daß die Modellierungseinheit 6 Komponenten zur parallelen Aktualisierung des Literal-Wörterbuches 2 enthält, wobei diese von
einem einzelnen Zeichen am Ausgang des Input-FIFO 8 bewirkt wird und dann stattfindet, wenn das Literal-Wörterbuch 2 nicht in der Lage ist, eine vorangegangene Codierung für das Zeichen am Ausgang des Input-FIFO 8 zu finden, und der Trie-Wörterbuchspeicher 4 keinen Internen Knoten NODE findet, der mit der aus mehreren Zeichen bestehenden Zeichenkette, die aktuell im Input-FIFO 8 enthalten ist, übereinstimmt.
Sie kann aber auch Komponenten zur parallelen Aktualisierung des Präfixes des von der Codierungseinheit 7 verwendeten Codewortes enthalten, wobei dieses Präfix durch die Codierungseinheit 7 auf der Grundlage des internen Status der Modellierungseinheit 6 aktualisiert wird und auf der Anzahl unterschiedlicher Codeworte beruht, die durch die Modellierungseinheit 6 zur Codierungseinheit 7 übertragen wurden.
Eine weitere Möglichkeit besteht darin, daß sowohl die Modellierungseinheit 6 als auch die Codierungseinheit 7 Aktualisierungskomponenten besitzen, die die hochkompakte Codierung von Ausgangscodeworten durchführen und in Form von Speicherkomponenten in der Modellierungseinheit 6 vorhanden sind, die auf den letzten vorhergehenden Internen Knoten NODE verweisen, der im Trie- Wörterbuchspeicher 4 benutzt wurde, und daß das Ausgangscodewort, das zur Codierungseinheit 7 übertragen wurde als Differenz des letzten vorangehenden genutzten Internen Knotens NODE und des aktuellen, zu übertragenden Knotens gebildet wird.
Die Modellierungseinheit 6, die Codierungseinheit 7, die Ausrichtungseinheit 9 und der Output-FIFO 12 können aber auch Komponenten zur Koordination des Parallelbetriebes mit unterschiedlichen und unabhängigen Codeworten enthalten und damit eine Pipeline, beginnend mit der Modellierungseinheit 6, bilden, wobei diese Komponenten aus Speichern in der Modellierungseinheit 6, der Codierungseinheit 7, der Ausrichtungseinheit 9 und dem Output-FIFO 12 bestehen, die das Codewort vom Ausgang des vorangegangenen Blockes enthalten und die das sich aus der Verarbeitung dieses Codewortes innerhalb der jeweiligen Einheit ergebende modifizierte Codewort während des nächsten Pipelineschrittes an die nächste Einheit in der Kompressionskette übertragen. Diese Pipeline ist dabei dergestalt organisiert, daß ein Stillstand für die Modellierungseinheit 6 während des Kompressionsvorgangs weitestgehend vermieden wird.
Nach einer Ausführungsform der Erfindung enthält die Dekompressionseinheit zur Dekompression digitaler Datenblöcke als Bestandteil des gesamten Datenkompressionssystems Komponenten zur Pufferung von Eingabe- Codeworten nach dem First-in-first-out-Verfahren, wobei diese Eingabe- Codeworte eine Codierung unterschiedlicher Länge für die ursprünglichen, nichtkomprimierten Symbole fester Länge repräsentieren. Der Trie- Wörterbuchspeicher 403 und das Literal-Wörterbuch 402 sind dabei mit einer Modellierungseinheit 404, die Komponenten für das Zusammenwirken mit dem aus mehr als einer Speicherposition bestehenden Trie-Wörterbuchspeicher 403 besitzt, verbunden, die ihrerseits zum einen über einen Output-FIFO 406, eine Interface-Einheit 409, einen Input-FIFO 410, eine Ausrichtungseinheit 407 mit einer Decodierungseinheit 405 und zum anderen mit einem Blockpuffer 408 und
direkt mit der Decodierungseinheit 405 verbunden ist. Die Ausrichtungseinheit 407, die vom Input-FIFO 410 gelieferte und an Bytegrenzen ausgerichtete Information in eine Codewortdarstellung variabler Länge umwandelt, erzeugt ein Byte-organisiertes Datenformat für die Decodierungseinheit 405, wobei sie Komponenten zum Empfang von Codeworten variabler Länge und zusätzlich Komponenten zur Bestimmung der korrekten Länge des Präfixes, der Knotennummer, des Knotentyps und der relativen Übereinstimmungslänge mit dem im Trie-Wörterbuchspeicher 403 existierenden Knoten, der durch das Codewort beschrieben wird, oder umgekehrt die korrekte Bitlänge des Präfixes und die relative Nummer des Einzelsymbols im Literal-Wörterbuch 402, enthält. Die Decodierungseinheit 405 enthält Komponenten zum Zusammenwirken mit der Modellierungseinheit 404 und ermittelt auf der Basis des Inhaltes der internen Register der Modellierungseinheit 404, des aktuellen Zustandes des Trie- Wörterbuchspeichers 403 und aus dem Codewort die richtige Knotennummer und die Position des ersten Symbols sowie die absolute Übereinstimmungslänge, falls das Codewort vom Node-Typ ist. Die Modellierungseinheit 404 ist auch parallel mit dem Literal-Wörterbuch 402 verbunden. Die Verbindung ist nötig, um die durch das Literal-Wörterbuch 402 definierte Code-Substitution zu übertragen, falls das Codewort vom Literal-Typ ist und eine Komponente zum Ausführen einer Multibyte-Kopieroperation enthält, die entweder ein früher aufgetretenes Symbol oder eine Zeichenkette aus der ermittelten Position im Blockpuffer oder Output- FIFO 406 zu der aktuellen Position im Output-FIFO 406 kopiert, wobei der Output- FIFO 406 Komponenten zur temporären Speicherung dieser an Bytegrenzen ausgerichteten Codeworte enthält, bis die spezifizierte Breite des Ausgangsbusses erreicht wird und ein geeigneter Zeitpunkt vorliegt, um die Ergebnisse der Dekompression über die Interface-Einheit 409 zum Ausgangsspeicher zu übertragen.
Bei dieser Variante besitzt die Modellierungseinheit 404
Aktualisierungskomponenten, die sowohl vorläufige als auch endgültige Knoten in den Trie-Wörterbuchspeicher 403 einfügen, wobei die Knoten bewirken, daß die aktuelle Zeichenkette im Ausgabespeicher oder dem entsprechenden FIFO, die durch ein Feld Position 211 gekennzeichnet ist, den aktuellen Status des Trie- Wörterbuchspeichers 403 beeinflußt, und wobei die vorläufige Information, die vorher durch die Modellierungseinheit 404 in den Trie-Wörterbuchspeicher 403 geschrieben wurde, den Verarbeitungsprozeß für den Fall beschleunigt, daß die endgültige Aktualisierung mit der vorläufigen identisch ist und demzufolge die endgültige Aktualisierung vermieden wird.
Es ist aber auch möglich, daß die Modellierungseinheit 404 Aktualisierungskomponenten für ein paralleles Update des Literal-Wörterbuches 402 besitzt, das von einem einzelnen, über den entsprechenden Input-FIFO 410 adressierten Zeichen ausgelöst wird, wobei der Aktualisierungsprozeß stattfindet, wenn die Modellierungseinheit 404 feststellt, daß kein interner Knoten im Trie- Wörterbuchspeicher 403 durch das aktuelle Codewort genutzt wird, das durch die Decodierungseinheit 405 geliefert wird.
Weiterhin ist möglich, daß die Modellierungseinheit 404 Aktualisierungskomponenten für eine parallele Aktualisierung des Präfixes des von der Decodierungseinheit 405 verwendeten Codewortes besitzt, wobei das
Präfix, das durch die Decodierungseinheit 405 auf der Grundlage des internen Status der Modellierungseinheit 404 und der Anzahl der unterschiedlichen Codeworte aktualisiert wurde, durch die Modellierungseinheit 404 zur Decodierungseinheit 405 übertragen wird, wobei die Decodierungseinheit 405 einen selbstbalancierenden Präfix-Baum verwendet und dieser Baum dem am häufigsten verwendeten Typ von Codeworten das kürzeste Präfix zuordnet.
Letztlich ist es aber auch möglich, daß der Input-FIFO 410, die Ausrichtungseinheit 407, die Decodierungseinheit 405, die Modellierungseinheit 404 und der Output-FIFO 406 Komponenten zur Koordination des Parallelbetriebes mit unterschiedlichen und unabhängigen Codeworten enthalten und damit ein Pipelining, beginnend bei der Ausrichtungseinheit 407, ausgeführt wird, wobei diese Komponenten aus Speichern in der Modellierungseinheit 404, der Decodierungseinheit 405, der Ausrichtungseinheit 407 und dem Output-FIFO 406 bestehen, die das Codewort vom Ausgang des vorangegangenen Blockes für den nächsten Bearbeitungsschritt speichern. Dabei ist die Pipeline so organisiert, daß das aus der Verarbeitung des aktuellen Codewortes innerhalb der jeweiligen Einheit ergebende modifizierte Codewort während des nächsten Pipelineschrittes an die nächste Einheit in der Kompressionskette übertragen wird. Durch diese Organisation der Pipelinekette wird ein Stillstand für die Modellierungseinheit 404 während des Dekompressionsvorgangs vermieden.
Abschließend zeigen Figur 5 und Figur 6 ein praktisches Ausführungsbeispiel für das Kompressionsverfahren, das durch die beschriebene Schaltungsanordnung ausgeführt wird, das Kompressionsverfahren für die Eingabezeichenkette "abcabbcaacbcbcaacx".
Es gibt eine Eingabezeichenkette, wobei die Position jedes Zeichens in dieser Zeichenkette numeriert ist und die Zählung mit Null beginnt. Als Startbedingung wird angenommen, daß sowohl der Trie-Wörterbuchspeicher 4 als auch das Literal-Wörterbuch 2 leer sind (Standardbedingung für die bevorzugte Schaltungslösung). Figur 5 zeigt die schrittweise Darstellung des Kompressionsprozesses. Figur 6 enthält die äquivalente Zustandsdarstellung des Trie-Wörterbuchspeichers 4, die ebenfalls den aktuellen Verarbeitungsstand widerspiegelt.
Zunächst werden die beiden Anfangszeichen der Kette a [Position 0] und b[1] untersucht (Hash-Funktion) um zu bestimmen, ob im Trie-Wörterbuchspeicher 4 eine Zeichenkette existiert, die mit ab beginnt. Während der Trie- Wörterbuchspeicher 4 Fehler meldet, d.h. eine solche Zeichenkette nicht existiert, ergibt die Suche nach dem Zeichen a im Literal-Wörterbuch 2, daß ein solches Literal bisher nicht eingetragen ist. Es wird als Neues Literal NLIT klassifiziert, mit einem O-Bit-Präfix versehen und in originaler Form [H61] übertragen. Unterdessen wird der Blattknoten LEAF I gebildet und a bekommt das Codewort 0 im Literal- Wörterbuch 2 zugewiesen. Das gleiche Verfahren wird für b[1] und c[2] wiederholt, weil für diese Anfangssymbole keine Übereinstimungen im Trie- Wörterbuchspeicher 4 gefunden werden.
Für die ab Position [3] beginnende Zeichenkette abb... wird eine Übereinstimmung mit I gefunden, sie wird daher mit [0] verglichen. Der Vergleich liefert als Ergebnis eine Übereinstimmung von genau zwei Zeichen. Jetzt wird ein Blattknoten LEAF
gebildet, der I als den Zielknoten (2 Terminalknoten vor dem laufenden) und 2 Symbole als die Übereinstimmungslänge beschreibt. Die Aktualisierung des Trie- Wörterbuchspeichers 4 erfolgt durch Bildung eines ersten Internen Knotens NODE 1 mit einer Tiefe von 2 durch Eintragung von 1 als Vater-Knoten von I und die Bildung des neuen Blattknotens LEAF IV. Das gleiche Verfahren wiederholt sich für die Zeichenkette bcaa... auf Position [5], das eine Übereinstimmung mit Knoten II (2 Terminalknoten zurück) und eine Übereinstimmung von 3 Symbolen findet; gleichzeitig wird der Trie- Wörterbuchspeicher 4 durch Bilden der Knoten 2 mit einer Tiefe von 3 sowie Knoten V aktualisiert.
Für das Paar a,c ab Position[8] kann keine Übereinstimmung im Trie- Wörterbuchspeicher 4 gefunden werden. Jedoch ist das Symbol a bereits im Literal-Wörterbuch gespeichert. Damit wird das Bekannte Literal KLIT 0 zum Decoder übertragen. Das gleiche trifft auf c[9] zu, das als Bekanntes Literal KLIT 2 codiert wird, da im Trie-Wörterbuchspeicher 4 keine Übereinstimmung für die Zeichenkette cb... gefunden wird.
Das Paar b,c auf Position [10,11] findet eine Trie-Übereinstimmung mit dem Internen Knoten NODE 2, der auf Position [5] verweist, aber die Übereinstimmung ist zu kurz, um die Übereinstimmungslänge 3 zu erreichen, die durch diesen Knoten repräsentiert wird. Folglich wird ein Interner Knoten NODE 2 ausgegeben, zusammen mit einer im Vergleich zum Vater-Knoten um 1 erhöhten Übereinstimmungslänge. Weil der Vater-Knoten in diesem Fall das Symbol b mit einer Tiefe von 1 ist und weiterhin der Interne Knoten NODE nur für Übereinstimmungen von zwei und mehr Zeichen gilt, wird nur ein Bit verwendet, um die spezielle Übereinstimmungslänge 2 auszudrücken, und zwar durch den Wert 0 (ein Wert 1 würde eine Übereinstimmung von 3 bedeuten, d.h. die Tiefe des Knotens 2 selbst).
Als nächster Schritt wird die Zeichenkette bcaacx [12] analysiert. Als erstes finden die durchgeführten Suchschritte im Trie-Wörterbuchspeicher 4 den Knoten 3 und erreichen seine Tiefe von 2, dann den Knoten 2 und erreichen seine Tiefe von 3, dann den Knoten V, die Suche beendend mit einer Tiefe von 5. In diesem Fall wird ein Blattknoten LEAF (-3,2) generiert als der Abstand bezüglich des aktuellen Terminalknotens und einer Tiefendifferenz zum Vater-Knoten von V (Knoten 2).
Das Beispiel endet mit der Codierung von x[17] als NLIT und der Übertragung von"0",[H78] zur Ausrichtungseinheit.
Man beachte, daß das Beispiel keine neue Ausbalancierung des Präfix-Baumes liefert und es die gleichen Startwerte für alle einbezogenen Codeworte verwendet.
Auch das Verfahren zur Wandlung eines Blocks von Eingabesymbolen in verschlüsselte Ausgabecodeworte variabler Länge in einem Datenblock- Kompressionssystem, soll nochmals zusammenhängend erklärt werden. Die Eingangssymbole werden in einen Input-FIFO 8 übertragen. Auf der Grundlage der ersten beiden Symbole am Ausgang des Input-FIFO 8 wird eine Hash- Adresse berechnet, die dazu benutzt wird, parallel im Trie-Wörterbuchspeicher 4
und in der Zero-Finder-Lookup-Tabelle 3 zu suchen, um schnell feststellen zu können, ob ein Interner Knoten NODE oder ein Blattknoten LEAF im Trie- Wörterbuchspeicher 4 existiert. Wenn die Suche im Trie-Wörterbuchspeicher 4 einen Internen Knoten NODE feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO 8 übereinstimmt, wird die Multi-Byte-Suche iterativ fortgesetzt, bis die längste Übereinstimmung der Eingangszeichenkette im Input- FIFO 8 mit existierenden Knoten des Trie-Wörterbuchspeichers 4 gefunden ist. Dieser Prozeß wird wiederholt, bis kein übereinstimmender Knoten mehr gefunden wird. Die Knotennummer wird in relativer Form bezüglich des letzten gebildeten Knotens codiert und das Codewort wird entweder als Interner Knoten NODE oder als Blattknoten LEAF im Trie-Wörterbuchspeicher 4 identifiziert. Die zur Codierungseinheit übertragene Übereinstimmungslänge wird in differentieller Form bezüglich des letzten bei der Suche durchlaufenen Knotens berechnet. Wenn die Suche im Trie-Wörterbuchspeicher 4 keinen Internen Knoten NODE feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO 8 übereinstimmt, wird über das Literal-Wörterbuch 2 festgestellt, ob das Codewort durch ein Bekanntes Literal KLIT und damit durch den Code variabler Länge dargestellt werden kann, der dem Zeichen bei seinem früheren Auftreten zugewiesen wurde. Anderenfalls wird das Zeichen als Neues Literal NLIT identifiziert und wird in der Originalform dargestellt, wenn es noch nicht im Literal- Wörterbuch 2 enthalten ist. Jedem Codewort-Typ wird ein Präfix variabler Länge entsprechend dem verwendeten Typ des Codeworts zugewiesen, wobei dieses Präfix über einen selbstbalancierenden Präfix-Baum auf der Grundlage der kumulierten, aktuellen Zählwerte für die unterschiedlichen Codewort-Typen ermittelt wird. Dabei wandelt sich das sich ergebende Codewort variabler Länge über eine Ausrichtungsoperation in ein an Bytegrenzen ausgerichtetes Ausgabeergebnis um, die ausgerichteten Ausgabe-Codeworte im Output FIFO 12 werden gespeichert und dort zu Gruppen zusammenfaßt, um eine effiziente Schreiboperation auf das endgültige Speichermedium hinsichtlich Zeitpunkt und Busbreite durchführen zu können. Auf diese Weise wird aus einem nicht komprimierten Block von Eingangssymbolen eine komprimierte Darstellung in Form eines Blocks von Ausgabe-Codeworten erzeugt.
Dabei ist es vorteilhaft, wenn sowohl für den Trie-Wörterbuchspeicher 4 als auch für das Literal-Wörterbuch 2 dynamische Wörterbücher verwendet werden und wenn zusätzliche Schritte zur Aktualisierung des Trie-Wörterbuchspeichers 4 und des Literal-Wörterbuchs 2 enthalten sind. Es wird eine Datenstruktur im Trie- Wörterbuchspeicher 4 erzeugt, bei der Interne Knoten NODE und Blattknoten LEAF nebeneinander im selben Wörterbuch existieren. Die Blattknoten LEAF beginnen dabei bei 1 und werden aufwärts gezählt, die Internen Knoten NODE beginnen mit der höchsten Zahl und werden abwärts gezählt, wobei beide Knotenarten nicht miteinander kollidieren. Wenn die Suche im Trie- Wörterbuchspeicher 4 einen Internen Knoten NODE feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO 8 übereinstimmt, jedoch in der exakten Länge mit jedem in dem Suchpfad vorhandenen Knoten nicht übereinstimmt, wird dieses Wörterbuch durch Erzeugen eines neuen Internen Knotens NODE aktualisert. Der Zählerstand für die Zahl der Internen Knoten NODE wird um 1 erniedrigt, und es wird ein neuer Blattknoten LEAF gebildet. Diesem neuen Blattknoten LEAF wird als Tiefe der Wert der Maximallänge dieser Zeichenkette zugewiesen und es erfolgt abschließend ein Erhöhen des
Endknotenzählers um 1. Wenn die Suche im Trie-Wörterbuchspeicher 4 einen Internen Knoten NODE feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO 8 übereinstimmt und gleichzeitig in der exakten Länge mit einem im Suchpfad vorhandenen Knoten übereinstimmt, werden Schritte zur Aktualisierung des erreichten Knotens durchgeführt, wobei dieser erreichte Knoten in seinem Positionsfeld den aktuellen Positionszeiger im Eingabedatenspeicher erhält. Dieses Verfahren wird ebenfalls ausgeführt wird, wenn es sich bei dem Internen Knoten NODE nicht um einen Blattknoten LEAF handelt und in diesem Fall Schritte zur Erzeugung eines neuen Blattknotens LEAF erfolgen, wobei dieser neue Blattknoten LEAF in seinem Positionsfeld den aktuellen Positionszeiger im Eingabedatenspeicher erhält, wobei abschließend ein Hochzählen des Endknotenzählers erfolgt. Wenn die Suche im Trie- Wörterbuchspeicher 4 höherer Ordnung keinen Internen Knoten NODE feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO 8 übereinstimmt, wird ein neuer Blattknoten LEAF in diesem Wörterbuch erzeugt, wobei dieser neue Blattknoten LEAF die maximale Länge erhält. Abschließend erfolgt dann ein Hochzählen des Endknotenzählers. Das Verfahren wird auch ausgeführt, wenn das Eingabezeichen am Ausgang des Input-FIFO 8 nicht im Literal-Wörterbuch 2 enthalten ist, wobei das Verfahren die Schritte zur Aktualisierung des Literal-Wörterbuches 2 beinhaltet, indem dem Eintrag, der dem Eingangssymbol entspricht, die Anzahl der bisher in diesem Block empfangenen neuen Symbole zugewiesen wird. Schließlich wird der Zähler für die bekannten Symbole um eins erhöht.
Eine Ausbildungsform des Verfahrens sieht vor, daß zur Decodierung des ursprünglichen Datenblocks aus einem codierten Block von Codeworten die in Bytes ausgerichteten Codeworte in den Input-FIFO 8 eingetragen werden, daß der Input-FIFO 8 diese byteausgerichteten Codeworte fester Länge in solche variabler Länge rückkonvertiert und diese als Eingangsgröße für den Decodierungsschritt zur Verfügung stellt, indem diese Codeworte auf der Grundlage des in dem betreffenden Codewort enthaltenen dynamischen Präfixes einem Neuen Literal NLIT, einem Bekannten Literal KLIT, einem Internen Knoten NODE oder einem Blattknoten LEAF zugeordnet werden. Dieses Verfahren wird ausgeführt, wenn das Codewort als Neues Literal NLIT erkannt wird und ein einzelnes Symbol im Codewort vorhanden ist, das direkt dem Output-FIFO 12 zugeleitet wird, oder wenn das Codewort als Bekanntes Literal KLIT erkannt wird und ein einzelnes Symbol vom Codewort über das Literal-Wörterbuch 2 rückübersetzt und dem Output-FIFO 12 zugeleitet wird, oder wenn das Codewort vom Typ her entweder ein Interner Knoten NODE oder ein Blattknoten LEAF im Trie-Wörterbuchspeicher 4 ist. Dabei liest das Verfahren aus dem Trie-Wörterbuchspeicher 4 den Vater- Knoten des betreffenden Internen Knotens NODE, um die frühere Blockposition zu bestimmen, an der eine ähnliche Zeichenkette im Output-FIFO 12 existiert sowie die Knotentiefe an den Decoder zurückliefert, der die Anzahl der für die Darstellung der relativen Länge benötigten Bits und den eigentlichen relativen Wert selbst berechnet. Die Berechnung erfolgt, indem diese relative Länge zum vorbezeichneten Vater-Knoten des Internen Knotens NODE addiert wird, und auf diese Weise die Parameter für die Durchführung der/des stattfindenden Kopier- Schritte(s) für mehrere Zeichen ermittelt werden. Dieser Kopiervorgang enthält alle Schritte, um von der Position, die durch das Positionsfeld dieses decodierten Internen Knotens NODE beschrieben wird, so viele Symbole in den Output-FIFO
12 zu kopieren, wie durch die vorbezeichnete absolute Länge der Kopie bestimmt ist. Dabei werden alle diese Schritte wiederholt, bis keine weiteren Codeworte zu decodieren sind und auf diese Weise der ursprüngliche Symbolblock aus dem komprimierten Block von Codeworten wiederhergestellt wird.
Es ist aber auch möglich, die dynamischen Wörterbücher sowohl für den Trie- Wörterbuchspeicher 4 als auch für das Literal-Wörterbuch 2 bei der Dekompression zu nutzen, wobei zusätzliche Schritte zur Aktualisierung des Trie- Wörterbuchspeichers 4 und des Literal-Wörterbuchs 2 enthalten sind. Wenn ein Codewort extrahiert wird, das einem Einzelzeichen entspricht, das in den Output- FIFO 12 übertragen werden soll, wird der Trie-Wörterbuchspeicher 4 höherer Ordnung durch Bildung eines neuen Blattknoten LEAF aktualisiert. Dieser neue Blattknoten LEAF erhält in seinem Positionsfeld den aktuellen Positionszeiger im Output-FIFO 12 und im Feld Zählerwert die maximale Länge. Abschließend erfolgt ein Hochzählen des Endknotenzählers. Gleichzeitig wird festgestellt, ob das decodierte Symbol nicht bereits im Literal-Wörterbuch 2 enthalten ist. In diesem Fall wird zusätzlich ein Aktualisierungsschritt im Literal-Wörterbuch 2 durchgeführt, bei dem dem Symbol an seiner zugehörigen Adresse die Zahl der bisher im Block neu empfangenen Zeichen entsprechend dem aktuellen Zählerwert zugewiesen wird. Schließlich wird dieser Zähler um eins erhöht.
Wenn ein Codewort extrahiert wird, das einem Internen Knoten NODE im Trie- Wörterbuchspeicher 4 entspricht, aber die absolute Längenübereinstimmung, berechnet aus der Summe der Länge dieses Codewortes und der Tiefe des Vater- Knotens, nicht mit der Knotentiefe dieses Knotens selbst übereinstimmt, wird der Trie-Wörterbuchspeicher 4 durch Bildung eines neuen Blattknotens LEAF aktualisiert, wobei dieser neue Blattknoten LEAF in seinem Positionsfeld den aktuellen Positionszeiger im Eingabedatenspeicher erhält. Abschließend erfolgt ein Hochzählen des Endknotenzählers. Es wird ein neuer Internen Knoten NODE gebildet, wobei dieser neue Interne Knoten NODE in seinem Positionsfeld den aktuellen Positionszeiger im Output-FIFO 12 erhält. Diesem neuen Internen Knoten NODE wird als Tiefe die absolute Übereinstimmungslänge der Zeichenkette zugewiesen, die beim Decodierungsprozeß berechnet wurde. Abschließend erfolgt ein Herunterzählen des Zählers für die Zahl der Internen Knoten NODE um eins.
Wenn ein Codewort extrahiert wird, das einem Internen Knoten NODE im Trie- Wörterbuchspeicher 4 entspricht und die absolute Längenübereinstimmung, berechnet aus der Summe der Länge dieses Codewortes und der Tiefe des Vater- Knotens, mit der Knotentiefe dieses Knotens selbst übereinstimmt, wird der Trie- Wörterbuchspeicher 4 durch Bildung eines neuen Blattknotens LEAF aktualisiert, wobei dieser neue Blattknoten LEAF in seinem Positionsfeld den aktuellen Positionszeiger im Output-FIFO 12 erhält. Abschließend erfolgt ein Hochzählen des Endknotenzählers.
Es gibt verschiedene Ausbildungsformen des Verfahrens hinsichtlich der Aktualisierung der Präfixe. Unter Verwendung dynamischer Präfixe können sowohl während der Kompression als auch während der Dekompression die Präfixe der Codewort-Typen aktualisiert werden. Die Präfixe können aktualisiert werden, sobald irgendeiner der zu den Elementen der Paare [Bekanntes Literal
KLIT, Blattknoten LEAF] und [Neues Literal NLIT, Interner Knoten NODE] gehörenden Zähler größer wird als der Zählerstand des anderen Elementes des Paares und dieses größere Element nun die kürzere für das Paar zur Verfügung stehende Codierung erhält und dieses Element nun mit dem größten Element des anderen Paares verglichen und wiederum dem größten Element die kürzere Codierung zugewiesen wird, wodurch der Präfix-Baum sich selbst ausbalanciert, um das kürzere Präfix dem häufiger aufgetretenen Codewort-Typ zuzuweisen.
Es ist aber auch möglich, die Initialwerte für die Präfixe
Neues Literal NLIT=> 0 (1 Bit), Bekanntes Literal KLIT => 10 (2 Bits),
Blattknoten LEAF => 110 (3 Bits) und Interner Knoten NODE => 111 (3 Bits) zu definieren, wobei diese Präfixe während des Kompressions- und
Dekompressionsvorgangs dynamisch modifiziert werden, oder die Initialwerte für die Präfixe im statischen Fall wie folgt zu definieren:
Neues Literal NLIT KLIT=> 110 (3 Bits), Bekanntes Literal => 0 (1 Bit),
Blattknoten LEAF => 10 (2 Bits, Interner Knoten NODE => 111 (3 Bits).
Bezugszeichenliste
1 Kompressionseinheit
2 Literal-Wörterbuch
3 Zero-Finder-Lookup-Tabelle
4 Trie-Wörterbuchspeicher
5 Vergleichseinheit
6 Modellierungseinheit
7 Codierungseinheit
8 Input-FIFO
9 Ausrichtungseinheit
10 Blockpuffer
11 Interface Einheit
12 Output-FIFO
13 I/O-Speicher
101 Literal Bus
102 ZeroFinder-LUT Bus
103 Speicherschnittstelle
104 Ergebnisvergleichsbus
105 Eingangsbus der Codierungseinheit
106 Byte-Eingabebus
107 Eingabebus der Ausrichtungseinheit
108 FIFO-Vergleichs-Bus
109 Puffer-Vergleichs-Bus
110 Eingabebus FIFO-In
111 Output-FIFO-Bus
112 Puffer-Eingabebus
113 I/O-Memory-Bus
114 Ausgabebus des Output FIFO
210 Vater
211 Position
212 Zählerwert
213 Neu
214 Knoten
301 Wurzelknoten
302 Knotengruppe I
303 Knotengruppe II
304 NLIT-Knoten-Zähler
305 LEAF-Knoten-Zähler
306 KLIT-Knoten-Zähler
307 NODE-Knoten-Zähler
308 Prioritätenkreis
401 Dekompressionseinheit
402 Literal-Wörterbuch
403 Trie-Wörterbuchspeicher
404 Modellierungseinheit
405 Decodierungseinheit
406 Output-FIFO
407 Ausrichtungseinheit
408 Blockpuffer
409 Interface Einheit
410 Input-FIFO
501 Literal-Wörterbuch-Bus
502 Speicherschnittstelle
503 Eingabepuffer-Bus
504 Ausgangsbus der Decodierungseinheit
505 Ausgabebus der Ausrichtungseinheit
506 Byte-Ausgabebus
507 FIFO-Puffer-Kopier-Bus
508 Eingabebus der Ausrichtungseinheit
509 Ausgabebus des Output-FIFO
510 Puffer-Ausgabe-Bus
511 Eingabe-Ausgabe-Bus
512 Eingabebus des FIFO-In
Claims
1. Blockdatenkompressionssystem, bestehend aus einer Kompressionseinrichtung und einer Dekompressionseinrichtung, mit Multi-Byte- Suche zur schnellen Kompression von Blöcken digitaler Daten, dadurch gekennzeichnet, daß die Kompressionseinrichtung einen Input-FIFO (8) enthält, um Eingangssymbole nach dem First-in-first-out Prinzip zu puffern, und dieser Input FIFO (8) mit einer Steuerungskomponente, einer Modellierungseinheit (6), verbunden ist, wobei diese Modellierungseinheit (6) mit einem Trie- Wörterbuchspeicher (4), einer Zero-Finder-Lookup-Tabelle (3), Suchkomponenten in Form einer Vergleichseinheit (5), Speicherkomponenten in Form eines Literal- Wörterbuches (2) und einer Codierungseinheit (7) verbunden ist, die wiederum über eine Ausrichtungseinheit (9) mit einem Output-FIFO (12) verbunden ist, daß der Trie-Wörterbuchspeicher (4) aus einer Vielzahl von Speicherstellen besteht, und die Modellierungseinheit (6) parallel auf diesen zugreift, wobei er das Wörterbuch höherer Ordnung bildet, das durch eine Hash-Funktion adressiert wird, die aus den ersten Zeichen, die im Input-FIFO (8) enthalten sind, berechnet wird, daß die Zero-Finder-Lookup-Tabelle (3) zur Vorausbestimmung ungenutzten Platzes im Wörterbuch höherer Ordnung dient, wobei die Modellierungseinheit (6) auf das Wörterbuch höherer Ordnung zugreift, um zu bestimmen, ob die im Input FIFO (8) enthaltene Zeichenkette durch einen beliebigen inneren oder externen Knoten, der in diesem Wörterbuch existiert, ersetzt werden kann, und wobei die Vergleichseinheit (5) den parallelen Vergleich mehrerer Zeichen durchführt, um die maximale Länge der Übereinstimmung zwischen dem betreffenden Knoten in diesem Wörterbuch und der Zeichenkette im Input-FIFO (8) zu bestimmen, daß das Literal-Wörterbuch (2) das Wörterbuch niedriger Ordnung bildet, wobei der Inhalt des Literal-Wörterbuches (2) zur Erzeugung der codierten Form für Zeichenketten der Länge 1 in der Modellierungseinheit (6) genutzt wird, wobei die Modellierungseinheit (6) bestimmt, ob das Ergebnis der parallelen Suche in der Vergleichseinheit (5) oder der Inhalt des Literal-Wörterbuches (2) als Ausgangsgröße der Modellierungseinheit (6) gewählt wird, daß die Modellierungseinheit (6) sowohl eine iterative parallele Suche durchführt, wenn ein oder mehrere im Trie-Wörterbuchspeicher (4) enthaltene Knoten die Übereinstimmungslänge mit der im Input-FIFO (8) befindlichen Zeichenkette erhöhen, als auch ein Pipelining der Ergebnisse zur Codierungseinheit (7) durchführt, die kompakte Ausgangscodeworte variabler Länge erzeugt, die eine relative Darstellung der Ausgangswerte der Modellierungseinheit (6) verwendet, wobei die Ausgangscodeworte aktuellen Zustand der Codierungseinheit (7) abhängig sind, daß die Codierungseinheit (7) Komponenten zum Pipelining dieses Ausgangscodewortes variabler Länge zur Ausrichtungseinheit (9), die das Ausgangscodewort variabler Länge in ein an Bytegrenzen ausgerichtetes Codewort umwandelt, enthält, und daß der Output-FIFO (12) Komponenten zur temporären Speicherung dieser an Bytegrenzen ausgerichteten Codeworte enthält, bis die spezifizierte Breite des Ausgangsbusses erreicht wird und ein geeigneter Ausgabezeitpunkt vorliegt, um auf diese Weise einen Block von nichtkomprimierten digitalen Eingabedaten mit Hilfe des Kompressionsprozesses in einen komprimierten Datenstrom zur Ausgabe über den Ausgabebus (114) des Output-FIFO (12) umzuwandeln.
2. Blockdatenkompressionssystem nach Anspruch 1 , dadurch gekennzeichnet, daß die Modellierungseinheit (6) Aktualisierungskomponenten zur Einfügung sowohl der vorläufigen als auch der endgültigen Informationen in das Wörterbuch höherer Ordnung enthält, die bewirken, daß die aktuelle Zeichenkette am Ausgang des Input-FIFO (8) den aktuellen Status des Trie-Wörterbuchspeichers (4), der das Wörterbuch höherer Ordnung enthält, beeinflußt, wobei die vorläufige Information den Kompressionsprozeß für den Fall beschleunigt, daß das endgültige Update mit dem vorläufigen Update identisch ist und demzufolge dieses endgültige Update vermieden wird.
3. Blockdatenkompressionssystem nach Anspruch 1 oder 2, dadurch gekennzeichnet, daß die Modellierungseinheit (6) Komponenten zur parallelen Aktualisierung des Literal-Wörterbuches (2) enthält, wobei diese von einem einzelnen Zeichen am Ausgang des Input-FIFOS (8) bewirkt wird und dann stattfindet, wenn das Literal-Wörterbuch (2) nicht in der Lage ist, eine vorangegangene Codierung für das Zeichen am Ausgang des Input-FIFOs (8) zu finden, und der Trie-Wörterbuchspeicher (4) keinen Internen Knoten NODE findet, der mit der aus mehreren Zeichen bestehenden Zeichenkette, die aktuell im Input-FIFO (8) enthalten ist, übereinstimmt.
4. Blockdatenkompressionssystem nach Anspruch 1 , 2 oder 3, dadurch gekennzeichnet, daß sie Komponenten zur parallelen Aktualisierung des Präfixes des von der Codierungseinheit (7) verwendeten Codewortes enthält, wobei dieses Präfix durch die Codierungseinheit (7) auf der Grundlage des internen Status der Modellierungseinheit (6) aktualisiert wird und auf der Anzahl unterschiedlicher Codeworte beruht, die durch die Modellierungseinheit (6) zur Codierungseinheit (7) übertragen wurden.
5. Blockdatenkompressionssystem nach einem der Ansprüche 1 bis 4, dadurch gekennzeichnet, daß sowohl die Modellierungseinheit (6) als auch die Codierungseinheit (7) Aktualisierungskomponenten besitzen, die die hochkompakte Codierung von Ausgangscodeworten durchführen und in Form von Speicherkomponenten in der Modellierungseinheit (6) vorhanden sind, die auf den letzten vorhergehenden Internen Knoten NODE verweisen, der im Trie- Wörterbuchspeicher (4) benutzt wurde, und daß das Ausgangscodewort, das zur Codierungseinheit (7) übertragen wurde als Differenz des letzten vorangehenden genutzten Internen Knotens NODE und des aktuellen, zu übertragenden Knotens gebildet wird.
6. Einrichtung nach einem der Ansprüche 1 bis 5, dadurch gekennzeichnet, daß die Modellierungseinheit (6), die Codierungseinheit (7), die Ausrichtungseinheit (9) und der Output-FIFO (12) Komponenten zur Koordination des Parallelbetriebes mit unterschiedlichen und unabhängigen Codeworten enthalten und damit eine Pipeline, beginnend mit der Modellierungseinheit (6), bilden, daß diese Komponenten aus Speichern in der Modellierungseinheit (6), der Codierungseinheit (7), der Ausrichtungseinheit (9) und dem Output-FIFO (12) bestehen, die das Codewort vom Ausgang des vorangegangenen Blockes enthalten und die das sich aus der Verarbeitung dieses Codewortes innerhalb der jeweiligen Einheit ergebende modifizierte Codewort während des nächsten Pipelineschrittes an die nächste Einheit in der Kompressionskette übertragen, und daß diese Pipeline dergestalt organisiert ist, daß ein Stillstand für die Modellierungseinheit (6) während des Kompressionsvorgangs weitestgehend vermieden wird.
7. Blockdatenkompressionssystem nach Anspruch 1 , dadurch gekennzeichnet, daß die Dekompressionseinheit zur Dekompression digitaler Datenblöcke als Bestandteil des gesamten Datenkompressionssystems einen Trie- Wörterbuchspeicher (403) und ein Literal-Wörterbuch (402) enthält, daß sie Komponenten zur Pufferung von Eingabe-Codeworten nach dem First-in- first-out-Verfahren enthält, wobei diese Eingabe-Codeworte eine Codierung unterschiedlicher Länge für die ursprünglichen, nichtkomprimierten Symbole fester Länge repräsentieren, daß der Trie-Wörterbuchspeicher (403) und das Literal- Wörterbuch (402) mit einer Modellierungseinheit (404), die Komponenten für das Zusammenwirken mit dem aus mehr als einer Speicherposition bestehenden Trie- Wörterbuchspeicher (403) besitzt, verbunden sind, die ihrerseits zum einen über einen Output-FIFO (406), eine Interface-Einheit (409), einen Input-FIFO (410), eine Ausrichtungseinheit (407) mit einer Decodierungseinheit (405) und zum anderen mit einem Blockpuffer (408) und direkt mit der Decodierungseinheit (405) verbunden ist, daß die Ausrichtungseinheit (407), die vom Input-FIFO (410) gelieferte und an Bytegrenzen ausgerichtete Information in eine Codewortdarstellung variabler Länge umwandelt. und ein Byte-organisiertes Datenformat für die Decodierungseinheit (405) erzeugt, wobei diese Decodierungseinheit (405) Komponenten zum Empfang von Codeworten variabler Länge und zusätzlich Komponenten zur Bestimmung der korrekten Länge des Präfixes, der Knotennummer, des Knotentyps und der relativen Übereinstimmungslänge mit dem im Trie-Wörterbuchspeicher (403) existierenden Knoten, der durch das Codewort beschrieben wird, oder umgekehrt die korrekte Bitlänge des Präfixes und die relative Nummer des Einzelsymbols im Literal- Wörterbuch (402), enthält, daß die Decodierungseinheit (405) Komponenten zum Zusammenwirken mit der Modellierungseinheit (404) enthält und auf der Basis des Inhaltes der internen Register der Modellierungseinheit (404), des aktuellen Zustandes des Trie-Wörterbuchspeichers (403) und aus dem Codewort die richtige Knotennummer und die Position des ersten Symbols sowie die absolute Übereinstimmungslänge ermittelt, falls das Codewort vom Node-Typ ist, und daß die Modellierungseinheit (404) auch parallel mit dem Literal-Wörterbuch (402) verbunden ist, um die durch das Literal-Wörterbuch (402) definierte Code- Substitution zu übertragen, falls das Codewort vom Literal-Typ ist und eine Komponente zum Ausführen einer Multibyte-Kopieroperation enthält, die entweder ein früher aufgetretenes Symbol oder eine Zeichenkette aus der ermittelten Position im Blockpuffer (408) oder Output-FIFO 406 zu der aktuellen Position im Output-FIFO (406) kopiert, wobei der Output-FIFO (406) Komponenten zur temporären Speicherung dieser an Bytegrenzen ausgerichteten Codeworte enthält, bis die spezifizierte Breite des Ausgangsbusses erreicht wird und ein geeigneter Zeitpunkt vorliegt, um die Ergebnisse der Dekompression über die Interface-Einheit (409) zum Ausgangsspeicher zu übertragen.
8. Blockdatenkompressionssystem nach Anspruch 7, dadurch gekennzeichnet, daß die Modellierungseinheit (404) Aktualisierungskomponenten besitzt, die sowohl vorläufige als auch endgültige Knoten in den Trie-Wörterbuchspeicher (403) einfügen, wobei die Knoten bewirken, daß die aktuelle Zeichenkette im Ausgabespeicher oder dem entsprechenden FIFO, die durch ein Feld Position (211) gekennzeichnet ist, den aktuellen Status des Trie-Wörterbuchspeichers (403) beeinflußt, und daß die vorläufige Information, die vorher durch die Modellierungseinheit (404) in den Trie-Wörterbuchspeicher (403) geschrieben wurde, den Verarbeitungsprozeß für den Fall beschleunigt, daß die endgültige Aktualisierung mit der vorläufigen identisch ist und demzufolge die endgültige Aktualisierung vermieden wird.
9. Blockdatenkompressionssystem nach Anspruch 7, dadurch gekennzeichnet, daß die Modellierungseinheit (404) Aktualisierungskomponenten für ein paralleles Update des Literal-Wörterbuches (402) besitzt, das von einem einzelnen, über den entsprechenden Input-FIFO (410) adressierten Zeichen ausgelöst wird, wobei der Aktualisierungsprozeß stattfindet, wenn die Modellierungseinheit (404) feststellt, daß kein interner Knoten im Trie-Wörterbuchspeicher (403) durch das aktuelle Codewort genutzt wird, das durch die Decodierungseinheit (405) geliefert wird.
10. Blockdatenkompressionssystem nach Anspruch 7, dadurch gekennzeichnet, daß die Modellierungseinheit (404) Aktualisierungskomponenten für eine parallele Aktualisierung des Präfixes des von der Decodierungseinheit (405) verwendeten Codewortes besitzt, wobei das Präfix, das durch die Decodierungseinheit (405) auf der Grundlage des internen Status der Modellierungseinheit (404) und der Anzahl der unterschiedlichen Codeworte aktualisiert wurde, durch die Modellierungseinheit (404) zur Decodierungseinheit (405) übertragen wird, wobei die Decodierungseinheit (405) einen selbstbalancierenden Präfix-Baum verwendet und dieser Baum dem am häufigsten verwendeten Typ von Codeworten das kürzeste Präfix zuordnet.
11. Blockdatenkompressionssystem nach Anspruch 7, dadurch gekennzeichnet.daß der Input-FIFO (410), die Ausrichtungseinheit (407), die Decodierungseinheit (405), die Modellierungseinheit (404) und der Output-FIFO (406) Komponenten zur Koordination des Parallelbetriebes mit unterschiedlichen und unabhängigen Codeworten enthalten und damit ein Pipelining, beginnend bei der Ausrichtungseinheit (407), ausgeführt wird, wobei diese Komponenten aus Speichern in der Modellierungseinheit (404), der Decodierungseinheit (405), der Ausrichtungseinheit (407) und dem Output-FIFO (406) bestehen, die das Codewort vom Ausgang des vorangegangenen Blockes für den nächsten Bearbeitungsschritt speichern, wobei die Pipeline so organisiert ist, daß das aus der Verarbeitung des aktuellen Codewortes innerhalb der jeweiligen Einheit ergebende modifizierte Codewort während des nächsten Pipelineschrittes an die nächste Einheit in der Kompressionskette übertragen wird und die Pipelinekette dergestalt organisiert ist, daß ein Stillstand für die Modellierungseinheit (404) während des Dekompressionsvorgangs vermieden wird.
12. Verfahren zur Wandlung eines Blocks von Eingabesymbolen in verschlüsselte Ausgabecodeworte variabler Länge in einem Datenblock-Kompressionssystem, das ein Trie-Wörterbuchspeicher (4), ein Literal-Wörterbuch (2), Eingabe- und Ausgabe-Puffer (FIFOs, First-in-first-out) und einen Multi-Byte-Suchmechanismus enthält, dadurch gekennzeichnet, daß die Eingangssymbole in einen Input-FIFO (8) übertragen werden, daß auf der Grundlage der ersten beiden Symbole am Ausgang des Input-FIFO (8) eine Hash-Adresse berechnet wird, die dazu benutzt wird, parallel im Trie-Wörterbuchspeicher (4) und in der Zero-Finder- Lookup-Tabelle (3) zu suchen, um schnell feststellen zu können, ob ein Interner Knoten (NODE) oder ein Blattknoten (LEAF) im Trie-Wörterbuchspeicher (4) existiert, daß, falls die Suche im Trie-Wörterbuchspeicher (4) einen Internen Knoten (NODE) feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO (8) übereinstimmt, die Multi-Byte-Suche iterativ fortgesetzt wird, bis die längste Übereinstimmung der Eingangszeichenkette im Input-FIFO (8) mit existierenden Knoten des Trie-Wörterbuchspeichers (4) gefunden ist und daß dieser Prozeß wiederholt wird, bis kein übereinstimmender Knoten mehr gefunden wird, daß die Knotennummer in relativer Form bezüglich des letzten gebildeten Knotens codiert und das Codewort entweder als Interner Knoten (NODE) oder als Blattknoten (LEAF) im Trie-Wörterbuchspeicher (4) identifiziert wird, daß die zur Codierungseinheit übertragene Übereinstimmungslänge in differentieller Form bezüglich des letzten bei der Suche durchlaufenen Knotens berechnet wird und daß andernfalls, falls die Suche im Trie-Wörterbuchspeicher (4) keinen Internen Knoten (NODE) feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO (8) übereinstimmt, über das Literal-Wörterbuch (2) festgestellt wird, ob das Codewort durch ein Bekanntes Literal (KLIT) und damit durch den Code variabler Länge dargestellt werden kann, der dem Zeichen bei seinem früheren Auftreten zugewiesen wurde und daß das Zeichen anderenfalls als Neues Literal (NLIT) identifiziert wird und in der Originalform dargestellt wird, wenn es noch nicht im Literal-Wörterbuch (2) enthalten ist, daß jedem Codewort-Typ ein Präfix variabler Länge entsprechend dem verwendeten Typ des Codeworts zugewiesen wird, wobei dieses Präfix über einen selbstbalancierenden Präfix-Baum auf der Grundlage der kumulierten, aktuellen Zählwerte für die unterschiedlichen Codewort-Typen ermittelt wird, wobei das sich ergebende Codewort variabler Länge über eine Ausrichtungsoperation in ein an Bytegrenzen ausgerichtetes Ausgabeergebnis umwandelt, die ausgerichteten Ausgabe- Codeworte im Output FIFO (12) speichert und dort zu Gruppen zusammenfaßt, um eine effiziente Schreiboperation auf das endgültige Speichermedium hinsichtlich Zeitpunkt und Busbreite durchführen zu können und auf diese Weise aus einem nicht komprimierten Block von Eingangssymbolen eine komprimierte Darstellung in Form eines Blocks von Ausgabe-Codeworten erzeugt.
13. Verfahren nach Anspruch 12, dadurch gekennzeichnet, daß sowohl für den Trie-Wörterbuchspeicher (4) als auch für das Literal-Wörterbuch (2) dynamische Wörterbücher verwendet werden und daß zusätzliche Schritte zur Aktualisierung des Trie-Wörterbuchspeichers (4) und des Literal-Wörterbuchs (2) enthalten sind, wobei eine Datenstruktur im Trie-Wörterbuchspeicher (4) erzeugt wird, bei der Interne Knoten (NODE) und Blattknoten (LEAF) nebeneinander im selben Wörterbuch existieren, die Blattknoten (LEAF) bei 1 beginnen und aufwärts gezählt werden, die Internen Knoten (NODE) mit der höchsten Zahl beginnen und abwärts gezählt werden, wobei beide Knotenarten nicht miteinander kollidieren, daß, falls die Suche im Trie-Wörterbuchspeicher (4) einen Internen Knoten (NODE) feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input- FIFO (8) übereinstimmt, jedoch in der exakten Länge mit jedem in dem Suchpfad vorhandenen Knoten nicht übereinstimmt, dieses Wörterbuch durch Erzeugen eines neuen Internen Knotens (NODE) aktualisert, den Zählerstand für die Zahl der Internen Knoten (NODE) um 1 erniedrigt sowie einen neuen Blattknoten (LEAF) bildet, wobei diesem neuen Blattknoten (LEAF) als Tiefe der Wert der Maximallänge dieser Zeichenkette zugewiesen wird und abschließend ein Erhöhen des Endknotenzählers um 1 erfolgt, daß, falls die Suche im Trie- Wörterbuchspeicher (4) einen Internen Knoten (NODE) feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO (8) übereinstimmt und gleichzeitig in der exakten Länge mit einem im Suchpfad vorhandenen Knoten übereinstimmt, Schritte zur Aktualisierung des erreichten Knotens durchführt, wobei dieser erreichte Knoten in seinem Positionsfeld den aktuellen Positionszeiger im Eingabedatenspeicher erhält, und es ebenfalls ausgeführt wird, wenn es sich bei dem Internen Knoten (NODE) nicht um einen Blattknoten (LEAF) handelt und in diesem Fall Schritte zur Erzeugung eines neuen Blattknotens (LEAF) erfolgen, wobei dieser neue Blattknoten (LEAF) in seinem Positionsfeld den aktuellen Positionszeiger im Eingabedatenspeicher erhält und abschließend ein Hochzählen des Endknotenzählers erfolgt, daß, falls die Suche im Trie- Wörterbuchspeicher (4) höherer Ordnung keinen Internen Knoten (NODE) feststellt, der in mehr als einem Zeichen mit der Zeichenkette im Input-FIFO (8) übereinstimmt, einen neuen Blattknoten (LEAF) in diesem Wörterbuch erzeugt, wobei dieser neue Blattknoten (LEAF) die maximale Länge erhält, und abschließend ein Hochzählen des Endknotenzählers erfolgt, und daß das Verfahren auch ausgeführt wird, wenn das Eingabezeichen am Ausgang des Input-FIFO (8) nicht im Literal-Wörterbuch (2) enthalten ist, wobei das Verfahren die Schritte zur Aktualisierung des Literal-Wörterbuches (2) beinhaltet, indem dem Eintrag, der dem Eingangssymbol entspricht, die Anzahl der bisher in diesem Block empfangenen neuen Symbole zugewiesen und schließlich der Zähler für die bekannten Symbole um eins erhöht wird.
14. Verfahren nach Anspruch 12 oder 13, dadurch gekennzeichnet daß zur Decodierung des ursprünglichen Datenblocks aus einem codierten Block von Codeworten die in Bytes ausgerichteten Codeworte in den Input-FIFO (8) eingetragen werden, daß der Input-FIFO (8) diese byteausgerichteten Codeworte fester Länge in solche variabler Länge rückkonvertiert und diese als Eingangsgröße für den Decodierungsschritt zur Verfügung stellt, in dem diese Codeworte auf der Grundlage des in dem betreffenden Codewort enthaltenen dynamischen Präfixes einem Neuen Literal (NLIT), einem Bekannten Literal (KLIT), einem Internen Knoten (NODE) oder einem Blattknoten (LEAF) zugeordnet werden, und daß es ausgeführt wird, wenn das Codewort als Neues Literal (NLIT) erkannt wird und ein einzelnes Symbol im Codewort vorhanden ist, das direkt dem Output-FIFO (12) zugeleitet wird, oder wenn das Codewort als Bekanntes Literal (KLIT) erkannt wird und ein einzelnes Symbol vom Codewort über das Literal-Wörterbuch (2) rückübersetzt und dem Output-FIFO (12) zugeleitet wird, oder wenn das Codewort vom Typ her entweder ein Interner Knoten (NODE) oder ein Blattknoten (LEAF) im Trie-Wörterbuchspeicher (4) ist, wobei das Verfahren aus dem Trie-Wörterbuchspeicher (4) den Vater-Knoten des betreffenden Internen Knoten (NODE) liest, um die frühere Blockposition zu bestimmen, an der eine ähnliche Zeichenkette im Output-FIFO (12) existiert sowie die Knotentiefe an den Decoder zurückliefert, der die Anzahl der für die Darstellung der relativen Länge benötigten Bits und den eigentlichen relativen Wert selbst berechnet, indem diese relative Länge zum vorbezeichneten Vater- Knoten des Internen Knotens (NODE) addiert wird, und auf diese Weise die Parameter für die Durchführung der/des stattfindenden Kopier-Schritte(s) für mehrere Zeichen ermittelt werden, wobei dieser Kopier-Vorgang alle Schritte enthält, um von der Position, die durch das Positionsfeld dieses Decodierten Internen Knotens (NODE) beschrieben wird, so viele Symbole in den Output-FIFO (12) zu kopieren, wie durch die vorbezeichnete absolute Länge der Kopie bestimmt ist, wobei alle diese Schritte wiederholt werden, bis keine weiteren Codeworte zu Decodieren sind und auf diese Weise der ursprüngliche Symbolblock aus dem komprimierten Block von Codeworten wiederhergestellt wird.
15. Verfahren nach Anspruch12, 13 oder 14, dadurch gekennzeichnet, daß die dynamischen Wörterbücher sowohl für den Trie-Wörterbuchspeicher (4) als auch für das Literal-Wörterbuch (2) bei der Dekompression genutzt werden und bei dem zusätzliche Schritte zur Aktualisierung des Trie-Wörterbuchspeichers (4) und des Literal-Wörterbuchs (2) enthalten sind, daß, wenn ein Codewort extrahiert wird, das einem Einzelzeichen entspricht, das in den Output-FIFO (12) übertragen werden soll und die Schritte umfaßt, der Trie-Wörterbuchspeicher (4) höherer Ordnung durch Bildung eines neuen Blattknoten (LEAF) zu aktualisieren und dieser neue Blattknoten (LEAF) in seinem Positionsfeld den aktuellen Positionszeiger im Output-FIFO (12) und im Feld Zählerwert die maximale Länge erhält und abschließend ein Hochzählen des Endknotenzählers erfolgt, es auch Prüfschritte umfaßt um festzustellen, ob das decodierte Symbol nicht bereits im Literal-Wörterbuch (2) enthalten ist, um in diesem Fall zusätzlich einen Aktualisierungsschritt im Literal-Wörterbuch (2) durchzuführen, bei dem dem Symbol an seiner zugehörigen Adresse die Zahl der bisher im Block neu empfangenen Zeichen entsprechend dem aktuellen Zählerwert zugewiesen werden und schließlich dieser Zähler um eins erhöht wird, daß, wenn ein Codewort extrahiert wird, das einem Internen Knoten (NODE) im Trie- Wörterbuchspeicher (4) entspricht, aber die absolute Längenübereinstimmung , berechnet aus der Summe der Länge dieses Codewortes und der Tiefe des Vater- Knotens nicht mit der Knotentiefe dieses Knotens selbst übereinstimmt und die Schritte umfaßt, den Trie-Wörterbuchspeicher (4) durch Bildung eines neuen Blattknotens (LEAF) zu aktualisieren, wobei dieser neue Blattknoten (LEAF) in seinem Positionsfeld den aktuellen Positionszeiger im Eingabedatenspeicher erhält und abschließend ein Hochzählen des Endknotenzählers erfolgt, einen neuen Internen Knoten (NODE) zu bilden, wobei dieser neue Knoten in seinem Positionsfeld den aktuellen Positionszeiger im Output-FIFO (12) erhält und diesem neuen Knoten als Tiefe die absolute Übereinstimmungslänge der Zeichenkette zugewiesen wird, die beim Decodierungsprozeß berechnet wurde und abschließend ein Herunterzählen des Zählers für die Zahl der Internen Knoten (NODE) um eins erfolgt, daß, wenn ein Codewort extrahiert wird, das einem Internen Knoten (NODE) im Trie-Wörterbuchspeicher (4) entspricht und die absolute Längenübereinstimmung, berechnet aus der Summe der Länge dieses Codewortes und der Tiefe des Vater-Knotens mit der Knotentiefe dieses Knotens selbst übereinstimmt und die Schritte umfaßt, den Trie-Wörterbuchspeicher (4) durch Bildung eines neuen Blattknotens (LEAF) zu aktualisieren, wobei dieser neue Blattknoten (LEAF) in seinem Positionsfeld den aktuellen Positionszeiger im Output-FIFO (12) erhält und abschließend ein Hochzählen des Endknotenzählers erfolgt.
16. Verfahren nach einem der Ansprüche 12 bis 15, dadurch gekennzeichnet, daß unter Verwendung dynamischer Präfixe, zusätzlich sowohl während der Kompression als auch während der Dekompression Schritte enthalten sind, in denen die Präfixe der Codewort-Typen aktualisiert werden, daß die Präfixe aktualisiert werden, sobald irgendeiner der zu den Elementen der Paare [Bekanntes Literal (KLIT), Blattknoten (LEAF)] und [Neues Literal (NLIT), Interner Knoten (NODE)] gehörenden Zählern größer wird als der Zählerstand des anderen Elementes des Paares und dieses größere Element nun die kürzere für das Paar zur Verfügung stehende Codierung erhält und dieses Element nun mit dem größten Element des anderen Paares verglichen und wiederum dem größten Element die kürzere Codierung zugewiesen wird, wodurch der Präfix-Baum sich selbst ausbalanciert, um das kürzere Präfix dem häufiger aufgetretenen Codewort-Typ zuzuweisen.
17. Verfahren nach einem der Ansprüche 12 bis 15, dadurch gekennzeichnet, daß die Initialwerte für die Präfixe wie folgt definiert sind:
Neues Literal (NLIT) => 0 (1 Bit)
Bekanntes Literal (KLIT) => 10 (2 Bits)
Blattknoten (LEAF) => 110 (3 Bits)
Interner Knoten (NODE) => 111 (3 Bits), wobei diese Präfixe während des Kompressions- und Dekompressionsvorgangs dynamisch modifiziert werden.
18. Verfahren nach einem der Ansprüche 12 bis 15, dadurch gekennzeichnet, daß die Initialwerte für die Präfixe im statischen Fall wie folgt definiert werden: Neues Literal (NLIT) => 110 (3 Bits)
Bekanntes Literal (KLIT) => 0 (1 Bit)
Blattknoten (LEAF) => 10 (2 Bits)
Interner Knoten (NODE) => 111 (3 Bits)
Applications Claiming Priority (3)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| DE10301362A DE10301362B4 (de) | 2003-01-16 | 2003-01-16 | Blockdatenkompressionssystem, bestehend aus einer Kompressionseinrichtung und einer Dekompressionseinrichtung, und Verfahren zur schnellen Blockdatenkompression mit Multi-Byte-Suche |
| DE10301362 | 2003-01-16 | ||
| PCT/DE2004/000039 WO2004066505A2 (de) | 2003-01-16 | 2004-01-15 | Blockdatenkompressionssystem, bestehend aus einer kompressionseinrichtung und einer dekompressionseinrichtung, und verfahren zur schnellen blockdatenkompression mit multi-byte-suche |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| EP1588493A2 true EP1588493A2 (de) | 2005-10-26 |
Family
ID=32667613
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| EP04702277A Ceased EP1588493A2 (de) | 2003-01-16 | 2004-01-15 | Blockdatenkompressionssystem, bestehend aus einer kompressionseinrichtung und einer dekompressionseinrichtung, und verfahren zur schnellen blockdatenkompression mit multi-byte-suche |
Country Status (4)
| Country | Link |
|---|---|
| US (1) | US7403136B2 (de) |
| EP (1) | EP1588493A2 (de) |
| DE (1) | DE10301362B4 (de) |
| WO (1) | WO2004066505A2 (de) |
Families Citing this family (85)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7348904B2 (en) * | 2004-02-19 | 2008-03-25 | Telefonaktiebolaget Lm Ericsson (Publ) | Selective updating of compression dictionary |
| US20060143171A1 (en) * | 2004-12-29 | 2006-06-29 | International Business Machines Corporation | System and method for processing a text search query in a collection of documents |
| US8811431B2 (en) | 2008-11-20 | 2014-08-19 | Silver Peak Systems, Inc. | Systems and methods for compressing packet data |
| US8929402B1 (en) * | 2005-09-29 | 2015-01-06 | Silver Peak Systems, Inc. | Systems and methods for compressing packet data by predicting subsequent data |
| US8489562B1 (en) | 2007-11-30 | 2013-07-16 | Silver Peak Systems, Inc. | Deferred data storage |
| US8885632B2 (en) | 2006-08-02 | 2014-11-11 | Silver Peak Systems, Inc. | Communications scheduler |
| US8755381B2 (en) | 2006-08-02 | 2014-06-17 | Silver Peak Systems, Inc. | Data matching using flow based packet data storage |
| US20080162522A1 (en) * | 2006-12-29 | 2008-07-03 | Guei-Yuan Lueh | Methods and apparatuses for compaction and/or decompaction |
| US7907783B2 (en) * | 2007-01-24 | 2011-03-15 | Samsung Electronics Co., Ltd. | Apparatus and method of matching symbols in a text image coding and decoding system |
| US9362948B2 (en) * | 2008-02-14 | 2016-06-07 | Broadcom Corporation | System, method, and computer program product for saving and restoring a compression/decompression state |
| US9331919B2 (en) * | 2007-11-30 | 2016-05-03 | Solarwinds Worldwide, Llc | Method for summarizing flow information of network devices |
| US8179799B2 (en) * | 2007-11-30 | 2012-05-15 | Solarwinds Worldwide, Llc | Method for partitioning network flows based on their time information |
| US8307115B1 (en) | 2007-11-30 | 2012-11-06 | Silver Peak Systems, Inc. | Network memory mirroring |
| US8601113B2 (en) * | 2007-11-30 | 2013-12-03 | Solarwinds Worldwide, Llc | Method for summarizing flow information from network devices |
| US9292567B2 (en) | 2007-12-12 | 2016-03-22 | Oracle International Corporation | Bulk matching with update |
| US8943057B2 (en) * | 2007-12-12 | 2015-01-27 | Oracle America, Inc. | Method and system for distributed bulk matching and loading |
| US8688621B2 (en) * | 2008-05-20 | 2014-04-01 | NetCee Systems, Inc. | Systems and methods for information compression |
| US10805840B2 (en) | 2008-07-03 | 2020-10-13 | Silver Peak Systems, Inc. | Data transmission via a virtual wide area network overlay |
| US9717021B2 (en) | 2008-07-03 | 2017-07-25 | Silver Peak Systems, Inc. | Virtual network overlay |
| US10164861B2 (en) | 2015-12-28 | 2018-12-25 | Silver Peak Systems, Inc. | Dynamic monitoring and visualization for network health characteristics |
| US8743683B1 (en) | 2008-07-03 | 2014-06-03 | Silver Peak Systems, Inc. | Quality of service using multiple flows |
| US20120265768A1 (en) * | 2008-10-08 | 2012-10-18 | Mitsubishi Electric Corporation | Encoding and decoding method and apparatus for multimedia signatures |
| US7868792B2 (en) * | 2009-02-05 | 2011-01-11 | Polytechnic Institute Of New York University | Generating a boundary hash-based hierarchical data structure associated with a plurality of known arbitrary-length bit strings and using the generated hierarchical data structure for detecting whether an arbitrary-length bit string input matches one of a plurality of known arbitrary-length bit springs |
| US8212695B2 (en) * | 2009-02-05 | 2012-07-03 | Polytechnic Institute Of New York University | Generating a log-log hash-based hierarchical data structure associated with a plurality of known arbitrary-length bit strings used for detecting whether an arbitrary-length bit string input matches one of a plurality of known arbitrary-length bit strings |
| JP5278534B2 (ja) * | 2009-03-19 | 2013-09-04 | 富士通株式会社 | 記憶媒体 |
| US9160611B2 (en) * | 2009-04-22 | 2015-10-13 | Webroot Inc. | System and method for performing longest common prefix strings searches |
| EP2362546B1 (de) * | 2010-02-26 | 2017-07-26 | BlackBerry Limited | Verfahren und Vorrichtung zur pufferbasierten verschachtelten Kodierung einer Eingabesequenz |
| US8077064B2 (en) | 2010-02-26 | 2011-12-13 | Research In Motion Limited | Method and device for buffer-based interleaved encoding of an input sequence |
| US7990297B1 (en) | 2010-02-26 | 2011-08-02 | Research In Motion Limited | Encoding and decoding methods and devices employing dual codesets |
| US8063801B2 (en) | 2010-02-26 | 2011-11-22 | Research In Motion Limited | Encoding and decoding methods and devices using a secondary codeword indicator |
| US8761240B2 (en) | 2010-07-13 | 2014-06-24 | Blackberry Limited | Methods and devices for data compression using context-based coding order |
| CA2798125C (en) | 2010-07-28 | 2016-04-05 | Research In Motion Limited | Method and device for compression of binary sequences by grouping multiple symbols |
| WO2012033498A1 (en) * | 2010-09-10 | 2012-03-15 | Hewlett-Packard Development Company, L.P. | Systems and methods for data compression |
| US8548057B2 (en) | 2011-01-25 | 2013-10-01 | Microsoft Corporation | Video coding redundancy reduction |
| US8456331B2 (en) | 2011-04-15 | 2013-06-04 | Cavium, Inc. | System and method of compression and decompression |
| US8350732B2 (en) * | 2011-05-11 | 2013-01-08 | Cavium, Inc. | Compression with adjustable quality/bandwidth capability |
| HUE050522T2 (hu) * | 2011-06-28 | 2020-12-28 | Samsung Electronics Co Ltd | Video kódolási és dekódolási eljárás felhasználva aritmetikai kódolást az utolsó szignifikáns együttható kétdimenziós jelzésével |
| US9130991B2 (en) | 2011-10-14 | 2015-09-08 | Silver Peak Systems, Inc. | Processing data packets in performance enhancing proxy (PEP) environment |
| US9626224B2 (en) | 2011-11-03 | 2017-04-18 | Silver Peak Systems, Inc. | Optimizing available computing resources within a virtual environment |
| US8868584B2 (en) * | 2012-01-13 | 2014-10-21 | International Business Machines Corporation | Compression pattern matching |
| US9749645B2 (en) | 2012-06-22 | 2017-08-29 | Microsoft Technology Licensing, Llc | Coded-block-flag coding and derivation |
| JP5949421B2 (ja) * | 2012-10-11 | 2016-07-06 | 富士通株式会社 | 情報処理装置、実行優先度変更方法およびプログラム |
| US9762359B2 (en) * | 2013-01-10 | 2017-09-12 | Telefonaktiebolaget Lm Ericsson (Publ) | E-HICH information transmitting method, base station and user equipment |
| US10506254B2 (en) | 2013-10-14 | 2019-12-10 | Microsoft Technology Licensing, Llc | Features of base color index map mode for video and image coding and decoding |
| JP6359101B2 (ja) | 2013-10-14 | 2018-07-18 | マイクロソフト テクノロジー ライセンシング,エルエルシー | ビデオ及び画像の符号化及び復号のためのイントラブロックコピー予測モードの特徴 |
| CN105659602B (zh) | 2013-10-14 | 2019-10-08 | 微软技术许可有限责任公司 | 用于视频和图像编码的帧内块复制预测模式的编码器侧选项 |
| CN105917650B (zh) | 2014-01-03 | 2019-12-24 | 微软技术许可有限责任公司 | 视频和图像编/解码的方法、计算设备及计算机可读介质 |
| US10390034B2 (en) | 2014-01-03 | 2019-08-20 | Microsoft Technology Licensing, Llc | Innovations in block vector prediction and estimation of reconstructed sample values within an overlap area |
| US11284103B2 (en) | 2014-01-17 | 2022-03-22 | Microsoft Technology Licensing, Llc | Intra block copy prediction with asymmetric partitions and encoder-side search patterns, search ranges and approaches to partitioning |
| US10542274B2 (en) | 2014-02-21 | 2020-01-21 | Microsoft Technology Licensing, Llc | Dictionary encoding and decoding of screen content |
| CN105099460B (zh) * | 2014-05-07 | 2018-05-04 | 瑞昱半导体股份有限公司 | 字典压缩方法、字典解压缩方法与字典建构方法 |
| CN105493505B (zh) | 2014-06-19 | 2019-08-06 | 微软技术许可有限责任公司 | 统一的帧内块复制和帧间预测模式 |
| US9948496B1 (en) | 2014-07-30 | 2018-04-17 | Silver Peak Systems, Inc. | Determining a transit appliance for data traffic to a software service |
| US9875344B1 (en) | 2014-09-05 | 2018-01-23 | Silver Peak Systems, Inc. | Dynamic monitoring and authorization of an optimization device |
| CA2959682C (en) | 2014-09-30 | 2022-12-06 | Microsoft Technology Licensing, Llc | Rules for intra-picture prediction modes when wavefront parallel processing is enabled |
| US9331712B1 (en) * | 2015-05-11 | 2016-05-03 | Qualcomm Incorporated | Compressed caching in a virtual memory system |
| EP3308540B1 (de) | 2015-06-09 | 2020-04-15 | Microsoft Technology Licensing, LLC | Robuste kodierung/dekodierung von escape-kodierten pixeln im palettenmodus |
| SE540178C2 (en) | 2016-01-29 | 2018-04-24 | Zeropoint Tech Ab | Methods, devices and systems for compressing and decompressing data |
| US10509580B2 (en) * | 2016-04-01 | 2019-12-17 | Intel Corporation | Memory controller and methods for memory compression utilizing a hardware compression engine and a dictionary to indicate a zero value, full match, partial match, or no match |
| US10432484B2 (en) | 2016-06-13 | 2019-10-01 | Silver Peak Systems, Inc. | Aggregating select network traffic statistics |
| US11500638B1 (en) | 2016-06-24 | 2022-11-15 | Apple Inc. | Hardware compression and decompression engine |
| US10528539B2 (en) * | 2016-07-01 | 2020-01-07 | Intel Corporation | Optimized selection of hash collision chains |
| US9967056B1 (en) | 2016-08-19 | 2018-05-08 | Silver Peak Systems, Inc. | Forward packet recovery with constrained overhead |
| US10892978B2 (en) | 2017-02-06 | 2021-01-12 | Silver Peak Systems, Inc. | Multi-level learning for classifying traffic flows from first packet data |
| US10257082B2 (en) | 2017-02-06 | 2019-04-09 | Silver Peak Systems, Inc. | Multi-level learning for classifying traffic flows |
| US11044202B2 (en) | 2017-02-06 | 2021-06-22 | Silver Peak Systems, Inc. | Multi-level learning for predicting and classifying traffic flows from first packet data |
| US10771394B2 (en) | 2017-02-06 | 2020-09-08 | Silver Peak Systems, Inc. | Multi-level learning for classifying traffic flows on a first packet from DNS data |
| JP7210130B2 (ja) * | 2017-04-07 | 2023-01-23 | 富士通株式会社 | 符号化プログラム、符号化方法および符号化装置 |
| US11212210B2 (en) | 2017-09-21 | 2021-12-28 | Silver Peak Systems, Inc. | Selective route exporting using source type |
| US10986349B2 (en) | 2017-12-29 | 2021-04-20 | Microsoft Technology Licensing, Llc | Constraints on locations of reference blocks for intra block copy prediction |
| US10637721B2 (en) | 2018-03-12 | 2020-04-28 | Silver Peak Systems, Inc. | Detecting path break conditions while minimizing network overhead |
| US10997123B2 (en) * | 2018-11-19 | 2021-05-04 | Fungible, Inc. | Matching techniques in data compression accelerator of a data processing unit |
| US11309908B2 (en) | 2018-11-26 | 2022-04-19 | Fungible, Inc. | Static dictionary-based compression hardware pipeline for data compression accelerator of a data processing unit |
| CN111384962B (zh) * | 2018-12-28 | 2022-08-09 | 上海寒武纪信息科技有限公司 | 数据压缩解压装置和数据压缩方法 |
| CN111384963B (zh) * | 2018-12-28 | 2022-07-12 | 上海寒武纪信息科技有限公司 | 数据压缩解压装置和数据解压方法 |
| WO2020130929A1 (en) * | 2018-12-21 | 2020-06-25 | Zeropoint Technologies Ab | Methods, devices and systems for efficient compression and decompression for higher throughput |
| CN110109896B (zh) * | 2019-04-13 | 2021-12-10 | 成都飞机工业(集团)有限责任公司 | Uav飞行参数智能还原方法 |
| US10756758B1 (en) | 2019-08-30 | 2020-08-25 | International Business Machines Corporation | Length-limited huffman encoding |
| US11630729B2 (en) | 2020-04-27 | 2023-04-18 | Fungible, Inc. | Reliability coding with reduced network traffic |
| US11366735B2 (en) | 2020-08-20 | 2022-06-21 | Bank Of America Corporation | Dynamic data storage management |
| CN112115232B (zh) * | 2020-09-24 | 2024-11-22 | 腾讯科技(深圳)有限公司 | 一种数据纠错方法、装置及服务器 |
| EP4489314A4 (de) * | 2022-02-28 | 2025-06-18 | Osaka University | Signalkomprimierungseinrichtung, signalwiederherstellungseinrichtung und signalverarbeitungssystem |
| CN115801017B (zh) * | 2022-08-23 | 2025-07-15 | 贵州电网有限责任公司 | 一种针对雷电波形数据动态压缩方法以及硬件实现方法 |
| US12086414B2 (en) | 2022-10-06 | 2024-09-10 | Macronix International Co., Ltd. | Managing content addressable memory devices |
| CN115664426B (zh) * | 2022-12-27 | 2023-03-21 | 深圳安德空间技术有限公司 | 一种探地雷达数据的实时无损压缩方法及系统 |
Family Cites Families (15)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US4464650A (en) * | 1981-08-10 | 1984-08-07 | Sperry Corporation | Apparatus and method for compressing data signals and restoring the compressed data signals |
| US4906991A (en) * | 1988-04-29 | 1990-03-06 | Xerox Corporation | Textual substitution data compression with finite length search windows |
| US5126739A (en) * | 1989-01-13 | 1992-06-30 | Stac Electronics | Data compression apparatus and method |
| US5146221A (en) * | 1989-01-13 | 1992-09-08 | Stac, Inc. | Data compression apparatus and method |
| US5016009A (en) * | 1989-01-13 | 1991-05-14 | Stac, Inc. | Data compression apparatus and method |
| US5406279A (en) * | 1992-09-02 | 1995-04-11 | Cirrus Logic, Inc. | General purpose, hash-based technique for single-pass lossless data compression |
| US5640551A (en) * | 1993-04-14 | 1997-06-17 | Apple Computer, Inc. | Efficient high speed trie search process |
| US5612693A (en) * | 1994-12-14 | 1997-03-18 | International Business Machines Corporation | Sliding window data compression using a toroidal bit shift register |
| US5627534A (en) * | 1995-03-23 | 1997-05-06 | International Business Machines Corporation | Dual stage compression of bit mapped image data using refined run length and LZ compression |
| JP3273119B2 (ja) * | 1995-09-29 | 2002-04-08 | 京セラ株式会社 | データ圧縮・伸長装置 |
| US5877711A (en) * | 1997-09-19 | 1999-03-02 | International Business Machines Corporation | Method and apparatus for performing adaptive data compression |
| US5874907A (en) * | 1997-09-19 | 1999-02-23 | International Business Machines Corporation | Method and apparatus for providing improved data compression efficiency for an adaptive data compressor |
| US6012061A (en) * | 1997-11-25 | 2000-01-04 | International Business Machines Corp. | Method and apparatus for deleting nodes in Patricia trees |
| US7167115B1 (en) * | 2005-08-26 | 2007-01-23 | American Megatrends, Inc. | Method, apparatus, and computer-readable medium for data compression and decompression utilizing multiple dictionaries |
| US7180433B1 (en) * | 2005-09-22 | 2007-02-20 | Tandberg Storage Asa | Fast data compression and decompression system and method |
-
2003
- 2003-01-16 DE DE10301362A patent/DE10301362B4/de not_active Expired - Fee Related
-
2004
- 2004-01-15 WO PCT/DE2004/000039 patent/WO2004066505A2/de not_active Ceased
- 2004-01-15 US US11/184,673 patent/US7403136B2/en not_active Expired - Fee Related
- 2004-01-15 EP EP04702277A patent/EP1588493A2/de not_active Ceased
Also Published As
| Publication number | Publication date |
|---|---|
| DE10301362A1 (de) | 2004-08-05 |
| WO2004066505A2 (de) | 2004-08-05 |
| US20070150497A1 (en) | 2007-06-28 |
| US7403136B2 (en) | 2008-07-22 |
| DE10301362B4 (de) | 2005-06-09 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| DE10301362B4 (de) | Blockdatenkompressionssystem, bestehend aus einer Kompressionseinrichtung und einer Dekompressionseinrichtung, und Verfahren zur schnellen Blockdatenkompression mit Multi-Byte-Suche | |
| DE60000912T2 (de) | Verfahren und Vorrichtung zur Datenkomprimierung von Netzwerkdatenpaketen unter Verwendung von paketweisen Hash Tabellen | |
| DE69704362T2 (de) | Datenkompressions-/dekompressionssystem anhand sofortiger zeichenfolgensucheverschachtelter wörterbuchaktualisierung | |
| DE60001210T2 (de) | Verfahren und Vorrichtung zur Datenkomprimierung von Netzwerkdatenpaketen | |
| DE69027606T2 (de) | Vorrichtung zur datenkompression | |
| DE69527679T2 (de) | Verfahren zur Datenkomprimierung und -Dekomprimierung | |
| DE19622045C2 (de) | Datenkomprimierungs- und Datendekomprimierungsschema unter Verwendung eines Suchbaums, bei dem jeder Eintrag mit einer Zeichenkette unendlicher Länge gespeichert ist | |
| DE4340591C2 (de) | Datenkompressionsverfahren unter Verwendung kleiner Wörterbücher zur Anwendung auf Netzwerkpakete | |
| DE68925798T2 (de) | Datenverdichtung | |
| DE69413347T2 (de) | Auf die Bytegrenze ausgerichtete Datenkomprimierung | |
| DE69023329T2 (de) | Vorrichtung zur adaptiven datenkompression für ein bandantriebssystem. | |
| DE3852341T2 (de) | Zeichenverarbeitungssystem mit Funktion zur Prüfung von Rechtschreibung. | |
| DE68907812T2 (de) | Verfahren und Vorrichtung zur Kodierung, Dekodierung und Übertragung von Daten in komprimierter Form. | |
| DE69706439T2 (de) | Rechnersortiersystem zur datenkompression | |
| DE112012004873B4 (de) | Hohe Bandbreitendekomprimierung von mit variabler Länge verschlüsselten Datenströmen | |
| DE102020110578A1 (de) | Selbstprüfungskompression | |
| DE68924138T2 (de) | Daten-kompressions/dekompressionsanordnung. | |
| DE2513862C2 (de) | Vorrichtung zum Decodieren von Codes minimaler Redundanz und variabler Länge | |
| DE69330196T2 (de) | Textkomprimierungstechnik unter Anwendung einer frequenzgeordneten Matrix von Wort-Nummern-Abbildungen | |
| EP2068448B1 (de) | Verfahren und Anordnung zur arithmetischen Enkodierung und Dekodierung mit Verwendung mehrerer Tabellen | |
| DE3485824T2 (de) | Verfahren zur datenkompression. | |
| DE69026924T2 (de) | Datenkomprimierungsverfahren | |
| DE69834695T2 (de) | Verfahren und Vorrichtung zur Datenkompression | |
| DE69522497T2 (de) | System und Verfahren zur Datenkompression | |
| DE112013006339T5 (de) | Kompression hoher Bandbreite um Datenströme zu Verschlüsseln |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PUAI | Public reference made under article 153(3) epc to a published international application that has entered the european phase |
Free format text: ORIGINAL CODE: 0009012 |
|
| 17P | Request for examination filed |
Effective date: 20050816 |
|
| AK | Designated contracting states |
Kind code of ref document: A2 Designated state(s): AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HU IE IT LI LU MC NL PT RO SE SI SK TR |
|
| AX | Request for extension of the european patent |
Extension state: AL LT LV MK |
|
| DAX | Request for extension of the european patent (deleted) | ||
| 17Q | First examination report despatched |
Effective date: 20070720 |
|
| STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: THE APPLICATION HAS BEEN REFUSED |
|
| 18R | Application refused |
Effective date: 20080625 |