(19)
(11)EP 1 346 537 B1

(12)EUROPEAN PATENT SPECIFICATION

(45)Mention of the grant of the patent:
29.07.2009 Bulletin 2009/31

(21)Application number: 01271727.8

(22)Date of filing:  12.12.2001
(51)Int. Cl.: 
H04L 29/06  (2006.01)
H04L 12/46  (2006.01)
(86)International application number:
PCT/SE2001/002746
(87)International publication number:
WO 2002/051098 (27.06.2002 Gazette  2002/26)

(54)

EFFICIENT MAPPING OF SIGNAL ELEMENTS TO A LIMITED RANGE OF IDENTIFIERS

EFFIZIENTE ABBILDUNG VON SIGNALELEMENTEN AUF EINEN BEGRENZTEN UMFANG VON KENNUNGEN

MAPPAGE EFFICACE D'ELEMENTS DE SIGNAUX A UNE GAMME LIMITEE D'IDENTIFICATEURS


(84)Designated Contracting States:
AT BE CH CY DE DK ES FI FR GB GR IE IT LI LU MC NL PT SE TR

(30)Priority: 20.12.2000 SE 0004736

(43)Date of publication of application:
24.09.2003 Bulletin 2003/39

(73)Proprietor: TELEFONAKTIEBOLAGET LM ERICSSON (publ)
164 83 Stockholm (SE)

(72)Inventors:
  • TORKELSSON, Kjell
    S-128 38 Skarpnäck (SE)
  • KLING, Lars-Örjan
    S-151 52 Södertälje (SE)
  • AHL, Haakan
    SE-113 21 Stockholm (SE)
  • DITMAR, Johan
    S-128 34 Skarpnäck (SE)

(74)Representative: Hedman, Anders 
Aros Patent AB P.O. Box 1544
751 45 Uppsala
751 45 Uppsala (SE)


(56)References cited: : 
EP-A1- 0 522 743
US-A- 5 477 537
US-A1- 5 920 900
US-A- 4 587 610
US-A- 6 097 725
  
      
    Note: Within nine months from the publication of the mention of the grant of the European patent, any person may give notice to the European Patent Office of opposition to the European patent granted. Notice of opposition shall be filed in a written reasoned statement. It shall not be deemed to have been filed until the opposition fee has been paid. (Art. 99(1) European Patent Convention).


    Description

    TECHNICAL FIELD OF THE INVENTION



    [0001] The present invention generally concerns the mapping of signal elements to a limited range of identifiers by means of hashing, and especially the selection of context identifiers to represent packet headers in Internet Protocol header compression, as well as cache mapping in computer systems.

    BACKGROUND OF THE INVENTION



    [0002] Hashing is a conventional technique commonly used in various applications for mapping a set of signal elements (arguments) to a limited range of numeric identifiers (keys) by means of a hash function. In hashing, a given signal element is mapped to an identifier based only on the signal element or appropriate parts thereof as input to the hash function, without any knowledge of the mapping between other signal elements and identifiers. Ideally, signal elements having the same content should be mapped to the same identifier, whereas signal elements of different contents should be mapped to different identifiers. However, hash functions are usually not capable of mapping all unique signal elements to distinct identifiers, and there is a considerable risk of different elements being mapped to the same identifier (a hash collision, also referred to as a clash).

    [0003] Therefore, a lot of research has been directed towards finding optimized hash functions with random and uniform distribution characteristics. However, the number of hash collisions is usually still considerable in many applications even though a "good" hash function is used. In many cases the number of hash collisions may be considerable even when the number of unique and simultaneously active signal elements to be mapped to the identifiers is as low as 30-40% of the total number of identifiers.

    [0004] Other attempts for reducing hash collisions include resolving the collisions by means of various complicated circuitry, for example as described in US Patent 5,920,900.

    [0005] US Patent 6,097,725 describes a method for searching a bit field address in an ATM system by computing a hash key for pointing to a first address among a large number of addresses followed by sequential reading of a smaller number of subsequent entries until a match occurs.

    [0006] For a more thorough understanding of conventional hashing and the problems associated therewith, hashing will now be described with reference to the particular problem of selecting context identifiers in Internet Protocol (IP) header compression.

    [0007] IP header compression reduces the negative impacts of large IP headers significantly and allows efficient bandwidth utilization. Header compression is generally based on the observation that in a packet stream, most header fields are identical in consecutive packets. For simplicity one may think of a packet stream, sometimes also referred to as a session, as all the packets sent from a particular source address and port to a particular destination address and port using the same transport protocol. A basic principle for compressing headers is to establish an association between the non-changing fields of the headers in a packet stream and a context identifier (CID), which is selected to represent the headers. Headers are then replaced by compressed headers, each of which contains CID information and possibly also information that is unique to the individual packet header.

    [0008] Fig. 1 is a schematic diagram illustrating a full header 1 with CID association as well as a corresponding compressed header 2. Typically, the header fields can be categorized into different categories depending on how the fields are expected to change between consecutive headers in a packet stream. Header compression standards such as RFC 2507 and RFC 2508 of the Internet Engineering Task Force provide such a classification for IPv6 base and extension headers, IPv4, TCP and UDP headers. In these standards, fields that are not expected to change are classified as NO_CHANGE, fields that can be inferred from other fields are classified as INFERRED, and fields that change in an unpredictable manner are classified as RANDOM. Information in RANDOM fields is normally included in the compressed headers, whereas information in INFERRED fields really does not have to be included in the compressed headers.

    [0009] Fig. 2 is a schematic diagram of two interconnected routers A and B, each with header compression/decompression capabilities. The routers 10, 20 are interconnected by one or more (bi-directional) links. Each router comprises a compressor 11/21 and a decompressor 13/23, each of which is connected to a respective context memory 12-1, 12-2/22-1, 22-2. To compress the headers of a packet stream, the compressor 11 in router A selects, for each packet header, a CID to represent the non-changing fields of the header and stores header information, possibly together with additional information, as a compression context in the context memory 12-1 of router A. The initial packet of the packet stream is transmitted with a full header (FH), including the selected CID, over a given link to router B, allowing the decompressor 23 of router B to extract the compression context and the CID. The extracted compression context is stored in the context memory 22-2 of router B. Subsequent packets belonging to the same packet stream are then transmitted with compressed headers (CH) to router B. The decompressor 23 of router B can use the corresponding CID values to lookup the appropriate compression context in the context memory 22-2 of router B, thus restoring the compressed headers to their original form. In order to alleviate problems with incorrect decompression, full headers are typically transmitted periodically, or with an exponentially increasing interval in slow-start mode, to refresh the compression context.

    [0010] Although many aspects of header compression are specified in detail in existing header compression standards, the CID selection mechanism is not. The maximum range of CID values is specified in the standards. TCP packets and non-TCP packets normally use separate sets of CID values with different maximum ranges. Different routers have to negotiate on which CID range to use before initiating transmission. In general, different links also use separate sets of CID values. The actual mechanism for generating and selecting CID values, however, is unspecified.

    [0011] There are some basic requirements on CID generation and selection. The CID values should be unique for all packet streams that are active on a given link at any given time so that different streams are mapped to different CID values. If two or more active packet streams map to the same CID (clashing), the degree of compression is reduced since each clash requires a new full header, redefining the context of the CID, to be transmitted instead of a compressed header. Generating a unique CID for each new packet stream is therefore very important for the overall efficiency of the compression algorithm.

    [0012] CID selection is also complicated by the fact that there is no mechanism for determining when a stream has terminated.

    [0013] Conventional methods for generating CID values are typically based on hashing, taking the non-changing header fields as input to a hash function to generate a corresponding CID value.

    [0014] In header compression applications, the total number of possible headers may be extremely large, while typically the CID range is maximized to 28 for TCP traffic and 216 for non-TCP traffic.

    [0015] Fig. 3 illustrates hash-based generation of CID values for addressing a context memory according to the prior art. For an incoming packet, the header fields classified as NO_CHANGE are used as input to a hash coder 30. A suitable hash function is implemented in the hash coder 30 to generate a CID value based on the given input. The generated CID value acts as an index to the context memory 12/22 and points to a specific address in the context memory to be used for storing corresponding header information as compression context. The context memory 12/22 has a limited size, here illustrated with 128 memory positions from 0 to 127. The corresponding CID values that are used for addressing the context memory define a CID space ranging from 0 to 127 (the CID range being equal to 128).

    [0016] Fig. 4 illustrates the problem of CID clashing as two packet streams map to the same CID value. If a first packet belonging to stream X is mapped to the CID value 120 in the CID space, the corresponding header is stored as compression context in position 120 of the context memory. When a subsequent packet belonging to another stream Y also is mapped to the CID value 120, we have a CID clash. When the clash occurs, the CID value 120 is redefined to represent the new stream Y and the compression context previously stored in memory position 120 is overwritten by the header of the new packet belonging to stream Y. In the overall header compression scheme, this also means that the full header of the new packet of stream Y has to be transmitted to the decompressor on the receiving side. The two packet streams X and Y will continue to clash during the entire time period in which both packet streams are active, alternately overwriting each others compression contexts and necessitating the transmission of full header packets. In conventional hash-based CID generation, clashes will be common even when the number of simultaneously active sessions is relatively small compared to the total CID range, leading to a significant reduction of the compression efficiency.

    [0017] In computer systems using cache memories, a similar problem is encountered when several memory addresses are mapped to the same cache line.

    [0018] US Patent 5,920,900 relates to hash-based translation employing iterative collision resolution on multiple levels.

    [0019] US Patent 4,587,610 relates to address translation in a computer system employing the virtual memory technique for programming applications. The idea is to improve the efficiency of a lookaside buffer in translating virtual-to-physical addresses, and particularly to reduce the risk for hash collisions when hashing is employed. This is accomplished by using a Content Addressable Memory (CAM) as a backup to the lookaside buffer.

    SUMMARY OF THE INVENTION



    [0020] The present invention overcomes these and other drawbacks of the prior art arrangements.

    [0021] It is a general object of the present invention to provide a hash-based mechanism for efficiently mapping a set of signal elements to a limited range of identifiers. In particular, it is desirable to reduce the number of hash collisions, also known as clashes. In this regard, it is a particular object of the invention to provide a method and system for mapping signal elements to a limited range of identifiers with a low probability of clashing.

    [0022] Still another object of the invention is to find a cost-effective realization of relatively low complexity for efficient mapping of signal elements to a limited range of identifiers.

    [0023] Another object of the invention is to improve the compression rate in IP header compression to allow better utilization of available bandwidth, especially for links of low and medium speed. In this respect, it is a particular object to find an improved CID allocation scheme. It is also an object of the invention to provide a method and system for efficient mapping of different packet streams to a limited range of CID identifiers with a low probability of CID clashes.

    [0024] Still another object of the invention is to improve cache mapping in computer systems, and to devise an efficient cache placement algorithm.

    [0025] These and other objects are met by the invention as defined by the accompanying patent claims.

    [0026] The general idea according to the invention is to emulate a "virtual" space of identifiers that is larger than the real space of identifiers. The larger virtual identifier space is generally implemented by an intermediate memory, which provides storage for identifiers assigned from the real space of identifiers. For each signal element to be mapped to an identifier, the intermediate memory is addressed by means of a larger hash value calculated from at least part of the signal element, thus allowing access to an identifier.

    [0027] The larger virtual space gives a better distribution of signal elements to the identifiers, and is a key feature for reducing the probability of different signal elements being mapped to the same identifier (clashing). If the intermediate memory has a range that is a factor f larger than the real space of identifiers and the identifiers are assigned from the real identifier space to the relevant positions in the intermediate memory in an efficient manner, the effect will be essentially the same as if the real space of identifiers was f times larger.

    [0028] In those cases when a perfect hash function can not be found, it is necessary to detect and handle clashes in the extended virtual space of identifiers to prevent the algorithm according to the invention from degenerating. A clash between a new signal element and another previously mapped signal element can be detected by comparing the hash value for the new signal element with the hash value associated with the already mapped signal element. If they match, the two signal elements map to the same identifier, and a clash is detected. In the case of a clash, the identifier will be reused for the new signal element. This corresponds to the way clashes are handled in conventional algorithms based on direct hashing to the real space of identifiers. This does not reduce the value of the algorithm according to the invention since clashes occur much more seldom in the extended virtual space.

    [0029] In particular, the invention is applicable to IP header compression and the mapping of packet streams to a limited range of context identifiers (CIDs). By means of an extended virtual CID space in which CID values are assigned from the real CID space, the risk for packet headers of different packet streams being mapped to the same context identifier can be reduced significantly. This in turn leads to improved utilization of the available bandwidth of the links used for transmitting the header compressed packet streams.

    [0030] When assigning a CID value to a new session, it is important that the CID value has a low probability of belonging to an already active session. Ideally, the utilization of the CIDs is monitored and the CID that has been inactive for the longest period of time, i.e. the least recently used CID, is assigned to the new session.

    [0031] Alternatively, by cyclically assigning CID values within the real range of context identifiers to new sessions, the "oldest assigned" CID is always selected for a new session. When the lifetimes of the sessions are more or less the same, there is a low probability that the oldest assigned CID is still active and hence this CID is a good candidate. The oldest assigned algorithm has turned out to provide a very cost-effective realization of relatively low complexity. Only a minimum of extra resources needs to be added to the already existing equipment for hash-based header compression.

    [0032] The invention is generally applicable to hashing problems, and can also be utilized to improve e.g. hash-based cache mapping in computer systems.

    [0033] The invention offers the following advantages:
    • Efficient mapping with reduced probability of clashing;
    • Cost-effective realization of low complexity;
    • Improved compression rate in IP header compression, thus allowing better utilization of available bandwidth;
    • Improved cache mapping in computer systems; and
    • Possibility to reduce the size of a context or cache memory, while still maintaining the same clashing probability.


    [0034] Other advantages offered by the present invention will be appreciated upon reading of the below description of the embodiments of the invention.

    BRIEF DESCRIPTION OF THE DRAWINGS



    [0035] The invention, together with further objects and advantages thereof, will be best understood by reference to the following description taken together with the accompanying drawings, in which:

    Fig. 1 is a schematic diagram illustrating a full header with CID association as well as a corresponding compressed header;

    Fig. 2 is a schematic diagram of two interconnected routers A and B, each with header compression/decompression capabilities;

    Fig. 3 is a schematic diagram illustrating hash-based generation of CID values for addressing a context memory according to the prior art;

    Fig. 4 is a schematic diagram illustrating the problem of CID clashing as two packet streams map to the same CID value;

    Fig. 5 is a schematic diagram illustrating a CID selection mechanism according to a preferred embodiment of the invention;

    Fig. 6A is a schematic diagram illustrating a basic "least recently used" algorithm for assigning CID values to the virtual CID space by using a sorted list;

    Fig. 6B is a schematic diagram illustrating a basic "oldest assigned" algorithm for cyclically assigning CID values to the virtual CID space using a NEXT CID register;

    Fig. 7 is a schematic flow diagram of a CID selection method based on the "least recently used" algorithm according to a preferred embodiment of the invention;

    Fig. 8 is a schematic flow diagram of a CID selection method based on the "oldest assigned" algorithm according to a preferred embodiment of the invention;

    Figs. 9A-D are schematic diagrams illustrating, for different values of f, the clashing probability as a function of the percentage of active CID values for a simple direct hashing algorithm on one hand and the extended CID generation algorithm of the invention on the other hand;

    Fig. 10 is a schematic diagram illustrating a typical cache-based memory structure in a computer system;

    Fig. 11 is a schematic diagram illustrating a cache line selection mechanism according to a preferred embodiment of the invention;

    Fig. 12A is a schematic diagram illustrating a basic "least recently used" algorithm for assigning cache line identifier (LID) values to the virtual LID space by using a sorted list;

    Fig. 12B is a schematic diagram illustrating a basic "oldest assigned" algorithm for cyclically assigning LID values to the virtual LID space using a NEXT LID register;

    Fig. 13 is a schematic flow diagram of a cache line selection method based on the "least recently used" algorithm according to a preferred embodiment of the invention; and

    Fig. 14 is a schematic flow diagram of a cache line selection method based on the "oldest assigned" algorithm according to a preferred embodiment of the invention.


    DETAILED DESCRIPTION OF EMBODIMENTS OF THE INVENTION



    [0036] Throughout the drawings, the same reference characters will be used for corresponding or similar elements.

    [0037] The general mechanism for mapping a set of signal elements to a limited range of identifiers will first be described with reference to the particular application of CID selection in IP header compression. Next, the invention will be described with reference to cache mapping in a computer system. It should though be understood that the invention is not limited thereto, and that the invention can be applied to other hashing problems as well.

    Emulating a larger virtual CID space in IP header compression



    [0038] Fig. 5 is a schematic diagram illustrating a CID selection mechanism according to a preferred embodiment of the invention. In the following example, it is assumed that a compressor is associated with a context memory 12/22 of a limited size, say 128 memory positions ranging from 0 to 127. The corresponding CID values 0 to 127 for addressing the context memory define a CID space having a limited range of 128. In clear contrast to the conventional CID generation based on direct hashing, the CID selection/generation mechanism according to the invention is based on an intermediate CID memory 40 of a range that is larger than the CID range. The intermediate CID memory 40 provides storage of CID values assigned from the real CID space, thereby emulating a larger virtual space of CID values. The virtual CID space is a factor f larger than the real CID space, where f is any real value larger than 1. In practice, it is convenient to use f values that are powers of 2, resulting in possible virtual CID ranges of 256, 512, 1024, ... for a real CID range of 128. Of course, other virtual CID ranges are also feasible.

    [0039] Now, a hash coder 30 or any other equivalent module for implementing a suitable hash function calculates a hash value X, preferably based on the NO_CHANGE fields of an incoming packet header. The calculated hash value X is used for addressing the intermediate CID memory 40 to get access to a CID. For example, the hash value X may be calculated using a standard 16-bit CRC and selecting a suitable number of output bits as the hash value. Of course, alternative hash functions may be used. Compared to direct hashing from a packet header to a CID value, the range of the hash values X used for addressing the intermediate CID memory 40 has to be larger than that of the CID values. This means that if the intermediate CID memory 40 has a range that is a factor f = 23 times larger than the real CID range, the hash values X are preferably 3 bits longer than the CID values.

    [0040] As mentioned above, the intermediate CID memory 40 provides storage of CID values assigned from the real CID space, allowing access to a CID when the CID memory is addressed by a hash value X. The accessed CID can then be used as an address to access the context memory 12/22. Assuming that CID values are assigned from the real CID space to the intermediate memory 40 to represent packet headers and corresponding packet streams in an efficient manner, the extended virtual CID space gives essentially the same effect as an f times larger real CID space.

    [0041] In the prior art, a reduction of the clashing probability can be obtained only by enlarging the real CID space, resulting in a larger context memory. The invention accomplishes the reduction of the clashing probability by using only an intermediate CID memory, without enlarging the context memory. Since the overall context memory is adapted for storing compression contexts in the form of large headers, enlarging the context memory will require much more extra memory than just adding an intermediate memory for storing relatively small CID values.

    [0042] Naturally, the invention can also be used for reducing the size of the context memory while maintaining the same clashing probability (instead of reducing the clashing probability without enlarging the context memory). This gives the router designer a higher degree of design freedom, making it possible to choose between smaller context memories on one hand and reduced clashing probability on the other. In fact, it is even possible to reduce the size of the context memory and reduce the clashing probability at the same time by using a smaller real CID range and selecting an appropriately larger factor f.

    Handling real clashes in the extended virtual CID space



    [0043] To prevent the proposed CID selection mechanism based on an extended virtual CID space from degenerating when there is a real clash in the extended virtual CID space, each hash value is preferably stored in relation to the corresponding header context in a special Identifier Address (IDA) field in the context memory 12/22 and compared to the hash value X leading to the clash. If they match, the CID is reused for the packet belonging to the new stream and the context is updated, including updating the IDA field, also referred to as the CID address field. This is consistent with using a real larger CID space with direct hashing and does not reduce the value of the algorithm according to the invention.

    [0044] However, it should be understood that for certain applications when a perfect hash function can be found, there is generally no need for the CID address field and the associated hash value comparison.

    Assigning CID values with a low probability of being active



    [0045] With regard to the assignment of CID values from the real CID space to the intermediate CID memory, it is important that a CID to be assigned to a new packet stream has a low probability of already belonging to an active packet stream. In this respect, the invention proposes two main schemes for CID assignment, although other schemes also are possible.

    The "least recently used" algorithm for assigning CID values



    [0046] Ideally, the CID that has been inactive during the longest period of time should be selected and used for a packet belonging to a new packet stream. According to a preferred embodiment of the invention, illustrated schematically in Fig. 6A, this is accomplished by maintaining a sorted list 50 in which CID values within the real CID range are arranged according to their use for representing packet streams. Preferably, the most recently used context identifiers are placed at the end of the list, and consequently the least recently used CID can be found at the head of the list. The least recently used CID, which is the CID that has been inactive for the longest period of time, is the best candidate to use when a new CID is to be assigned. In hardware, the realization of the "least recently used" algorithm for assigning CID values to the virtual CID space becomes quite complex. Therefore this algorithm is more suitable for implementation in software, preferably by means of the linked list concept.

    The "oldest assigned" algorithm for assigning CID values



    [0047] Another scheme, illustrated schematically in Fig. 6B, assigns new CID values cyclically. Preferably the CID values within the CID range are traversed in sequential order, and when the last CID value is reached the process starts all over again with the first CID value, for example 0, 1, 2, ..., 127, 0, 1, 2, and so on. Naturally, the CID to be assigned next is stored in a NEXTCID register 60 for easy assignment to the relevant position in the intermediate memory. This results in the "oldest assigned" CID being selected for a packet belonging to a new packet stream. There is a fairly low probability that this CID is still active, and therefore this CID is a good candidate to be used when a new CID is to be assigned. If the lifetimes of all sessions are roughly the same, the "least recently used" algorithm and the "oldest assigned" algorithm are equally good.

    [0048] Even when the lifetimes of the sessions differ from each other, the "oldest assigned" algorithm can be improved to almost match the "least recently used" algorithm with a simple addition. For each packet, the corresponding CID can be compared to the CID value to be assigned next (NEXTCID). If they match, the CID has been detected as active and the NEXTCID register 60 is stepped or incremented to take the value of the "next to oldest assigned" CID. This will reduce clashes in mixed traffic of long and short sessions.

    [0049] When two routers that operate with different CID ranges are negotiating to determine which CID range to use in header compression, it is easy to select a given CID range by determining when the wrap-around in the cyclical assignment should take place. It is thus possible to traverse only a subset of the total CID range and start over from the beginning of the subset when the last CID in the subset is reached.

    [0050] The "oldest assigned" algorithm is particularly suitable for hardware implementation.

    [0051] In both algorithms, each location in the CID memory 40 can be initialized with any valid CID. For the "least recently used" algorithm, the CID list 50 can be initialized with CID values arranged in any arbitrary order.

    CID selection based on the "least recently used" algorithm



    [0052] Assuming that there exists a header compression implementation using simple direct hashing, the following resources are added:
    • An intermediate CID memory for storing CID numbers. The CID memory has a range that is a factor f larger than the range of the real CID space.
    • A sorted CID list, logic for maintaining the sorted list as well as registers or equivalent pointing to the head and tail, respectively, of the list. The CID list has a range equal to the real CID range and contains all possible CID values.
    • A new type of field in the context memory (called the CID address field) for storing, for each header context in the context memory, the address (equal to the hash value) of the CID memory in which the corresponding CID is stored.
    • Logic for performing the necessary comparisons.


    [0053] The overall CID selection algorithm based on the "least recently used" algorithm will now be described with reference to the flow diagram of Fig. 7.

    [0054] Perform the following steps for each packet:

    S1: Generate a hash value X with a range f times larger than the real CID range. The hash value is generally generated by a hashing method, applied to at least part of the packet header, preferably those fields that are classified as NO_CHANGE in header compression standards.

    S2: Address the intermediate CID memory by using X to get a CID.

    S3: Address the context memory by using the CID to get header information and the CID memory address (hash value) associated with the stored header information.

    S4: Compare the header of the received packet with the header information accessed from the context memory.

    S5: If they match (on-going packet stream), use the CID to represent the packet and place the CID at the end of the CID list.

    S6: If they don't match (a new packet stream), compare X to the CID address in the relevant CID address field in the context memory.

    S7: If X does not match the CID address (no clash in the virtual CID space), use the CID at the head of the CID list to represent the packet and place the CID last in the CID list. Update the CID memory by the new CID. Update the addressed position in the context memory by header information from the received packet and store the corresponding hash value X (the new CID address) calculated for that packet in the CID address field.

    S8: If X matches the CID address (a clash in the virtual CID space), reuse the same CID for the new packet, and update the context memory with regard to header information as well as CID address.



    [0055] If a certain CID is not used for a while (for example because the session to which the CID has been assigned no longer is active) the CID will successively move up in the CID list until it is at the head of the list at which time it will be taken by a new session.

    CID selection based on the "oldest assigned" algorithm



    [0056] In this embodiment, the following resources are added to an existing header compression implementation based on simple direct hashing:
    • An intermediate CID memory for storing CID numbers. The CID memory has range that is a factor f larger than the range of the real CID space.
    • A register, referred to as the NEXTCID register, for holding the next CID to be assigned to a new stream.
    • A new type of field in the context memory (called the CID address field) for storing, for each header context in the context memory, the CID memory address (equal to the hash value) in which the corresponding CID is stored.
    • Simple logic for performing the necessary comparisons.


    [0057] The overall CID selection algorithm based on the "oldest assigned" algorithm will now be described with reference to the flow diagram of Fig. 8.

    [0058] Perform the following steps for each packet:

    S11 to S 14 correspond to S1 to S4.

    S15: If they match (on-going packet stream), use the CID to represent the packet. If the next CID value is monitored for activity and the CID is equal to NEXTCID, increment NEXTCID.

    S16: If they don't match (a new packet stream), compare the calculated hash value X to the CID address in the relevant CID address field in the context memory.

    S17: If X does not match the CID address (no clash in the virtual CID space), use the CID value in the NEXTCID register to represent the packet, and update the CID memory by the CID from the NEXTCID register. Increment NEXTCID. Update the addressed position in context memory by the header of the received packet and store the corresponding hash value X (the new CID address) calculated for that packet in the CID address field.

    S18: If X matches the CID address (a clash in the virtual CID space), reuse the same CID for the new packet, and update the context memory with regard to header information as well as CID address. If the next CID value is monitored for activity and the CID is equal to NEXTCID, increment NEXTCID.



    [0059] Compared to simple hashing, the invention will significantly reduce the probability of different packet streams being mapped to the same CID. This leads to a considerable improvement of the compression rate and therefore better utilization of the available bandwidth of the links.

    [0060] The efficiency of the invention has been investigated in connection with IP header compression, and an analysis is given in Appendix A.

    [0061] For a more thorough understanding of how the invention can be applied to other hashing applications, the invention will now be described with reference to cache mapping in a computer system.

    Cache mapping in computer systems



    [0062] In most modern computer systems, the main memories are often relatively slow with rather long access times and considered as the bottlenecks of the computer systems. In this context, it is important to keep in mind that faster memory components are generally much more expensive than the slower memory components used as main memories. A common way of alleviating this problem is to use one or more levels of small and fast cache as a buffer between the processor and the larger and slower main memory.

    [0063] A cache memory contains copies of blocks of data/instructions that are stored in the main memory. In the cache, these blocks of data/instructions corresponds to cache line data fields. As reads to the main memory are issued in the computer system, the system first goes to the fast cache to determine if the information is present in the cache. If the information is available in the cache, a so-called cache hit, access to the main memory is not required and the required information is taken directly from the cache. If the information is not available in the cache, a so-called cache miss, the data is fetched from the main memory into the cache, possibly overwriting other active data in the cache. Similarly, as writes to the main memory are issued, data is written to the cache and copied back to the main memory. In most applications, the use of a cache memory speeds up the operation of the overall memory system significantly. The goal is to make the memory system appear to be as large as the main memory and as fast as the cache memory.

    [0064] It has also been found useful to provide an extremely rapid cache directly on the processor chip. Such an on-chip cache is commonly referred to as a level 1 (L1) cache. Typically, there is also an off-chip cache, commonly referred to as a level 2 (L2) cache.

    [0065] Fig. 10 is a schematic diagram illustrating a typical cache-based memory structure in a computer system. The cache-based memory structure may be included in any general-purpose computer known to the art. As the skilled person will understand, the description is not intended to be complete with regard to the entire computer system, but concentrates on those parts that are relevant to the use of cache memories in computer systems.

    [0066] In the particular example of Fig. 10, the computer system utilizes a typical two-level cache. The processor 100 is provided with an on-chip cache 101 (level 1 cache), and also connected to an off-chip cache 102 (level 2 cache). In this example, the off-chip cache 102 is connected to the processor 100 via a dedicated memory bus (including data, address and control bus). As most modem microprocessors, the processor 100 may have two caches on each level, one cache for data and another cache for instructions. For simplicity however, only a single cache is illustrated on each level. Further, the processor 100 is connected to a main memory 103, normally via a conventional memory controller 104. The caches 101, 102 are typically implemented using SRAMs (Static Random Access Memory) or similar high speed memory circuits, while the main memory 103 is typically implemented using slower DRAM (Dynamic Random Access Memory) circuits.

    [0067] Of course, instead of the two-level cache of Fig. 10, it is possible to utilize a single-level cache system as well as a cache system with more than two levels.

    [0068] Naturally, the processor includes functionality for controlling both the L1 and L2 cache memories. The performance of a cache is affected by the organization of the cache in general, and the placement algorithm in particular. The placement algorithm determines to which blocks or lines in the relevant cache that data in the main memory are mapped. The most commonly used algorithms are direct mapping, set-associative and fully associative mapping.

    [0069] In direct mapping, which is the simplest scheme, a hash function (such as a conventional modulo function) is usually applied to the memory address to determine which cache line to use. With reference to Table I below, an example of an illustrative memory address is shown.
    Table I - 32 bit memory address.
    311918 54 0
                   
    Address info concerning which of a number of possible memory blocks that is mapped to the cache line   Cache line number     Byte offset  


    [0070] Assuming that the cache line is 32 bytes and the cache size is 16 kB, the five least significant bits 0 to 4 give the byte offset in the cache line data field. The next 14 bits 5 to 18 determine in which cache line the data must be stored. The remaining 13 bits 19 to 31 of redundant addressing implies that 213=8132 possible memory blocks can be mapped to the same cache line. The cache has to store the address information in these bits as a tag in order to know which memory block that is currently stored there.

    [0071] The most complex scheme, fully associative mapping, makes use of associative addressing that allows data from any address in the main memory to be placed in any block in the cache.

    [0072] A set-associative cache lies between the two extremes of a direct mapped cache and a fully associative cache. In an n-way set-associative cache, the cache RAM is divided into n memory banks, or "ways". Each memory address maps to a certain location in any one of the n memory banks, and there is a choice of n memory banks for storage/retrieval of the actual data. A direct-mapped cache is a one-way set-associative cache.

    [0073] Direct mapping in a cache memory is comparable to direct mapping in IP header compression. The physical location in the cache to which a memory address of the main memory is mapped to is generally determined by direct hashing from appropriate parts of the memory address, and there is normally a relatively high probability that several memory addresses map to the same cache location and therefore overwrite each other. This also holds true for n-way set-associative caches.

    [0074] The use of an intermediate memory for emulating an extended larger virtual space of cache line identifiers can improve the mapping of direct-mapped and set-associative caches in the same way as the compression efficiency is improved in the IP header compression applications described above.

    Emulating a larger virtual cache-line-identifier space in cache mapping



    [0075] With reference to Fig. 11, a cache line selection mechanism according to a preferred embodiment of the invention will now be outlined.

    [0076] It is assumed that a computer system is associated with a cache memory 101/102 of a limited size, say 4096 cache lines ranging from 0 to 4095. The corresponding cache line identifier (LID) values 0 to 4095 for addressing the cache memory define a LID space having a limited range of 4096. Logically, the cache memory is preferably organized in such a way that each cache line in the cache memory 101/102 includes a valid field (V), a tag field (TAG), an identifier address field (IDA) as well as a data field (DATA). The valid field indicates whether the data field contains valid information. The tag field contains the address information required to identify whether a word in the cache corresponds to a requested word. The IDA field corresponds to the CID address field in header compression applications, and the DATA field holds the relevant data/instructions. Of course, it is possible to find various different physical realizations of the above logical organization of the cache memory.

    [0077] In clear contrast to conventional cache mapping based on direct hashing, the cache line selection mechanism according to the invention is based on an intermediate memory 140 of a range that is larger than the LID range. The intermediate memory 140 provides storage of cache line identifier values assigned from the real LID space, thereby emulating a larger virtual space of LID values. The virtual LID space is a factor f larger than the real LID space, where f is any real value larger than 1.

    [0078] A hash coder 130 or any other equivalent module for implementing a suitable hash function calculates a hash value X, based on appropriate parts of a current address in the main memory. For example, the hash value may be calculated from the so-called cache line number part of the incoming memory address together with an appropriate number of bits from the so-called tag part of the memory address (see Table I). The calculated hash value X is used for addressing the intermediate memory 140 to get access to a LID. Compared to direct hashing from a memory address, the range of the hash values X used for addressing the intermediate memory 140 has to be larger than that of the LID values.

    [0079] The intermediate memory 140 provides storage of LID values assigned from the real LID space, allowing access to a LID when the intermediate memory is addressed by a hash value X. The accessed LID can then be used to access a cache line in the cache memory 101/102. Assuming that LID values are assigned from the real LID space to the intermediate memory 140 in an efficient manner, the extended virtual LID space gives essentially the same effect as an f times larger real LID space.

    [0080] In short, a hash value is calculated based on a memory address of interest. The hash value is utilized to address an intermediate memory in which the actual cache line address is stored. The tag part of the memory address is compared to stored tag information to determine if we have a cache hit or a cache miss. If they match, the data has been found. If not, we pick a new cache line. The selection of a new cache line can be done using the least recently used algorithm or the oldest assigned algorithm.

    Handling real clashes in the extended virtual LID space



    [0081] In those cases when a perfect hash function can not be found,' it is necessary to detect and handle clashes in the extended virtual identifier space to prevent the proposed cache line selection mechanism from degenerating. Preferably, each hash value is stored in relation to the corresponding tag information in the special IDA field in the cache memory 101 / 102 and compared to the hash value X leading to the clash. If they match, the cache line identified by the LID is updated, including updating the IDA field. This is consistent with using a real larger LID space with direct hashing and does not reduce the value of the algorithm according to the invention.

    [0082] Depending on how the hash value is calculated from the incoming memory address, the memory address (in the form of the hash value) of the identifier in the intermediate memory may be deduced directly from the tag information. This means that the IDA field will become redundant, and may be removed.

    [0083] For completeness, the application of the "least recently used" algorithm and the "oldest assigned" algorithm to cache mapping will now be described with reference to the flow diagrams of Fig. 13 and Fig. 14, respectively.

    Cache line selection based on the "least recently used" algorithm



    [0084] Assuming that there exists a cache implementation using direct mapping or set-associative mapping, the following resources are added:
    • An intermediate memory for storing cache line identifiers. The LID memory has a range that is a factor f larger than the range of the real LID space.
    • A sorted list 150 (see Fig. 12A), logic for maintaining the sorted list as well as registers pointing to the head and tail, respectively, of the list. The list has a range equal to the real LID range and contains all possible LID values.
    • A new type of field in the cache memory (called the Identifier Address field) for storing, for each relevant memory address, the address (equal to the hash value) of the intermediate memory in which the corresponding LID is stored.
    • Logic for performing the necessary comparisons.


    [0085] The overall cache line selection algorithm based on the "least recently used" algorithm will now be described with reference to the flow diagram of Fig. 13.

    [0086] Perform the following steps for each main memory address of interest:
    S21:
    Generate a hash value X. The hash value is generally generated by a hashing method applied to at least part of the incoming memory address.
    S22:
    Address the intermediate LID memory by using X to get a LID.
    S23:
    Address the cache memory by using the LID to access tag information and the LID address (hash value) associated with the stored tag information.
    S24:
    Compare the tag of the memory address with the tag information accessed from the cache memory.
    S25:
    If they match (cache hit), use the cache line and place the LID at the end of the list.
    S26:
    If they don't match (a cache miss), compare X to the LID address in the relevant IDA field.
    S27:
    If X does not match the LID address (no clash in the virtual LID space), use the LID at the head of the list and place the LID last in the list. Update the intermediate memory by the new LID.
    S28:
    If X matches the LID address (a clash in the virtual LID space), reuse the cache line for the new memory address.


    [0087] If a certain LID is not used for a while, that LID will successively move up in the list until it is at the head of the list.

    Cache line selection based on the "oldest assigned" algorithm



    [0088] Assuming that there exists a cache implementation using direct mapping or set-associative mapping, the following resources are added:
    • An intermediate memory for storing cache line identifiers. The LID memory has range that is a factor f larger than the range of the real LID space.
    • A register, referred to as the NEXTLID register 160 (see Fig. 12B), for holding the next LID to be assigned.
    • A new type of field in the cache memory (called the Identifier Address field) for storing, for each relevant memory address, the address (equal to the hash value) of the intermediate memory in which the corresponding LID is stored.
    • Simple logic for performing the necessary comparisons.


    [0089] The overall cache line selection mechanism based on the "oldest assigned" algorithm will now be described with reference to the flow diagram of Fig. 14.

    [0090] Perform the following steps for each packet:
    S31 to S34
    correspond to S21 to S24.
    S35:
    If they match (cache hit), use the cache line. If the next LID value is monitored for activity and the LID is equal to NEXTLID, increment NEXTLID.
    S36:
    If they don't match (a cache miss), compare the calculated hash value X to the LID address in the relevant IDA field.
    S37:
    If X does not match the LID address (no clash in the virtual LID space), use the LID value in the NEXTLID register, and update the intermediate memory by the LID from the NEXTLID register. Increment NEXTLID.
    S38:
    If X matches the LID address (a clash in the virtual LID space), reuse the cache line for the new memory address.


    [0091] For further information on cache memories, reference is made to Computer Organization and Design: The Hardware/Software Interface by Patterson and Hennessy, 2nd ed., Morgan Kaufmann Publishers, San Francisco, pp. 540-627.

    [0092] As mentioned above, the proposed mapping mechanism is not limited to CID selection in IP header compression and cache mapping in computer systems but can also be applied to other hashing problems. Examples of other applications in which hashing can be improved by the invention include searching databases and performing various table lookups for IP routing.

    [0093] The embodiments described above are merely given as examples, and it should be understood that the present invention is not limited thereto. Further modifications, changes and improvements which retain the basic underlying principles disclosed and claimed herein are within the scope of the invention.

    APPENDIX A


    Performance of CID generation based on simple direct hashing



    [0094] It is assumed that a simple hashing scheme is used for generating CID values, where C is the number of possible CID values (the maximum CID range) and S is the number of simultaneously active sessions.

    [0095] To calculate the amount of packet streams that do not clash and therefore can be compressed, we first consider a single specific CID. The probability that exactly k sessions map to this CID is equal to:



    [0096] The probability that exactly one session maps to this CID is therefore equal to:



    [0097] The expected number of CID values that have exactly one session mapped to them is then equal to:



    [0098] The number of sessions that do not clash is equal to the number of CID values that only have one session mapped to them. Accordingly, the fraction of sessions that clash is equal to:


    Performance of CID generation by means of an extended virtual CID space



    [0099] The situation of having a virtual CID space, which is a factor f larger than the real CID space C, can be modeled thinking of the number of possible CID values as effectively becoming f times larger. For calculating the performance of the CID selection mechanism according to the invention, expression (4) above derived for direct hashing can be used with the number of possible CID values being equal to f·C (effectively replacing C by C).

    Comparison



    [0100] Figs. 9A-D are schematic diagrams illustrating, for different values of f, the clashing probability as a function of the percentage (p) of active CID values for a simple direct hashing algorithm (Pdirect) on one hand and the extended CID generation algorithm (Pextended) of the invention on the other hand. In Figs. 9A-D, the clashing probability for the direct hashing algorithm is indicated by a solid line, whereas the clashing probability for the extended algorithm is indicated by a dashed line. In the given plots, C has been set to a typical value of 1024. As can be seen, the CID selection mechanism according to the invention outperforms the conventional direct hashing mechanism.


    Claims

    1. A system for mapping signal elements to a first limited range of identifiers by means of a hash coder (30; 130), wherein said identifiers are used for addressing a first memory, characterized in that

    said system comprises an additional intermediate memory (40; 140) of a second larger range for storing identifiers assigned from the first limited range, thus emulating a larger virtual space of identifiers, and

    said hash coder (30; 130) is adapted for calculating, for each one of a plurality of signal elements, a hash value based on at least part of the signal element for addressing the intermediate memory (40; 140) to access an identifier, which in turn works as an address for access to said first memory,

    thereby reducing the risk for clashes.


     
    2. The system according to claim 1,
    characterized by means for detecting and handling a clash in the virtual space of identifiers.
     
    3. The system according to claim 2,
    characterized in that said clash detecting and handling means comprises:

    - means for detecting the mapping of a new signal element to the same identifier as a different and previously mapped signal element based on a comparison of the hash value associated with the new signal element and a hash value associated with the already mapped signal element; and

    - means for using the identifier for the new signal element in response to detection of such a mapping.


     
    4. The system according to any of the claims 1 to 3,
    characterized by means for cyclically assigning identifiers within the first limited range to the intermediate memory (40; 140).
     
    5. The system according to any of the claims 1 to 4,
    characterized in that said signal elements are packet headers and said identifiers are context identifiers, and the hash value is calculated based on at least one header field specified as no-change according to header compression standards.
     
    6. The system according to any of the claims 1 to 4,
    characterized in that said signal elements are memory addresses and said identifiers are cache line identifiers, and the hash value is calculated based on at least part of the memory address.
     
    7. The system according to any of the claims 1 to 4, characterized in that said signal elements are incoming packets and said identifiers are context identifiers, and said hash coder (30) is operable for calculating, for each of a plurality of said incoming packets, a hash value based on those parts of the packet header that do not change between successive packets in a packet stream for addressing the intermediate memory (40) to access a context identifier,
    thereby reducing the risk for packet headers of different packet streams being mapped to the same context identifier.
     
    8. The system according to claim 7,
    characterized by means for detecting and handling a clash in the virtual space of context identifiers.
     
    9. The system according to claim 8,
    characterized in that said clash detecting and handling means comprises:

    - means for comparing, for an incoming packet belonging to a new packet stream, the calculated hash value for the incoming packet with a hash value associated with a header context stored in a context memory (12/22) at a location corresponding to the context identifier accessed from the intermediate memory (40) by means of the calculated hash value;

    - means for allowing, in response to a match in the comparison due to clashing, the context identifier accessed from the intermediate memory (40) to represent the new packet stream; and

    - means for updating the context memory (12/22) by storing the context-forming part of the packet header of the incoming packet at a location corresponding to the accessed context identifier, and for associating the corresponding hash value with the stored header context.


     
    10. The system according to claim 9,
    characterized by:

    - means for updating, in response to a mismatch in the comparison, the accessed context identifier in the intermediate memory (40) by the oldest assigned context identifier; and

    - means for allowing, in response to a mismatch in the comparison, the oldest assigned context identifier to represent the packet header and the corresponding packet stream.


     
    11. The system according to any of the claims 7 to 10,
    characterized by means for cyclically assigning context identifiers within the first limited range to the intermediate memory (40) to represent new packet streams.
     
    12. The system according to claim 11,
    characterized by means for skipping a context identifier in the cyclic assignment of context identifiers if the context identifier is detected as active.
     
    13. The system according to claim 9,
    characterized by:

    - means for updating, in response to a mismatch in the comparison, the accessed context identifier in the intermediate memory by the least recently used context identifier; and

    - means for allowing, in response to a mismatch in the comparison, the least recently used context identifier to represent the packet header and the corresponding packet stream.


     
    14. The system according to any of the claims 7 to 9,
    characterized by means for assigning the least recently used context identifier to the intermediate memory to represent a packet belonging to a new packet stream.
     
    15. The system according to claim 13 or 14,
    characterized by means for arranging context identifiers within the first limited range in a sorted list (50) according to their use for representing packet streams with the most recently used context identifiers at the end of the list, wherein the context identifier at the head of the list is used as the least recently used context identifier.
     
    16. The system according to claim 7,
    characterized by:

    - means for addressing a context memory (12/22) based on the accessed context identifier to obtain a corresponding header context;

    - means for performing a comparison between the context-forming part of the current packet header and the obtained header context;

    - means for, in response to a match in the comparison, allowing the context identifier to represent the packet header and the corresponding packet stream;

    - means for, in response to a mismatch in the comparison:

    - performing a further comparison between the calculated hash value of the current packet header and a hash value associated with the obtained header context in the context memory; and

    - in response to a match in the further comparison due to clashing, allowing the accessed context identifier to represent the packet header and the corresponding packet stream;

    - in response to a mismatch in the further comparison, updating the accessed context identifier in the intermediate memory by the oldest assigned context identifier or the least recently used context identifier, allowing this context identifier to represent the packet header and the corresponding packet stream; and

    - updating the context memory by storing the context-forming part of the current packet header at the memory location corresponding to the context identifier allowed to represent the packet header, and associating the corresponding hash value with the context-forming header part.


     
    17. The system according to any of the claims 1 to 4, characterized in that said signal elements are memory addresses and said identifiers are cache line identifiers, and said hash coder (130) is operable for calculating, for each of said memory addresses, a hash value based on at least part of the memory address for addressing the intermediate memory (140) to access a cache line identifier,
    thereby reducing the risk for different memory addresses being mapped to the same cache line identifier.
     
    18. The system according to claim 17,
    characterized by means for detecting and handling a clash in the virtual space of cache line identifiers.
     
    19. The system according to claim 18,
    characterized in that said clash detecting and handling means comprises :

    - means for comparing, for a new memory address, the calculated hash value of the memory address with a hash value associated with a tag stored in a cache memory line that corresponds to the cache line identifier accessed from the intermediate memory (140) by means of the calculated hash value;

    - means for allowing, in response to a match in the comparison due to clashing, access to the cache memory line identified by the accessed cache line identifier; and

    - means for updating the cache memory line identified by the accessed cache line identifier by storing the tag of the new memory address, and for associating the corresponding hash value to the stored tag.


     
    20. The system according to claim 19,
    characterized by:

    - means for updating, in response to a mismatch in the comparison, the accessed cache line identifier in the intermediate memory (140) by the oldest assigned cache line identifier; and

    - means for allowing, in response to a mismatch in the comparison, access to the cache memory line identified by the oldest assigned cache line identifier.


     
    21. The system according to any of the claims 17 to 20,
    characterized by means for cyclically assigning cache line identifiers within the first limited range to the intermediate memory (140).
     
    22. The system according to claim 21,
    characterized by means for skipping a cache line identifier in the cyclic assignment of cache line identifiers if the cache line identifier is detected as active.
     
    23. The system according to claim 19,
    characterized by:

    - means for updating, in response to a mismatch in the comparison, the accessed cache line identifier in the intermediate memory by the least recently used cache line identifier; and

    - means for allowing, in response to a mismatch in the comparison, access to the cache memory line identified by the least recently used cache line identifier.


     
    24. The system according to any of the claims 17 to 19,
    characterized by means for assigning the least recently used cache line identifier to the intermediate memory to allow access to the corresponding cache memory line.
     
    25. The system according to claim 23 or 24,
    characterized by means for arranging cache line identifiers within the first limited range in a sorted list (150) according to their use, with the most recently used cache line identifiers at the end of the list, wherein the cache line identifier at the head of the list is used as the least recently used cache line identifier.
     
    26. The system according to claim 17,
    characterized by:

    - means for obtaining tag information from a cache memory line identified by the accessed cache line identifier;

    - means for performing a comparison between the tag of the memory address and the obtained tag information;

    - means for, in response to a match in the comparison, allowing access to the cache memory line identified by the accessed cache line identifier;

    - means for, in response to a mismatch in the comparison:

    - performing a further comparison between the calculated hash value of the memory address and a hash value associated with the obtained tag information; and

    - in response to a match in the further comparison due to clashing, allowing access to the cache memory line identified by the accessed cache line identifier;

    - in response to a mismatch in the further comparison, updating the accessed cache line identifier in the intermediate memory (140) by the oldest assigned cache line identifier or the least recently used cache line identifier, allowing access to the cache memory line identified by this cache line identifier; and

    - updating the accessed cache memory line by storing the tag of the memory address, and associating the corresponding hash value to the stored tag.


     
    27. The system according to claim 1,
    characterized in that said first memory is a context memory or a cache memory.
     
    28. The system according to claim 1,
    characterized in that said first memory is a context memory and said identifiers are context identifiers.
     
    29. The system according to claim 1,
    characterized in that said first memory is a cache memory and said identifiers are cache line identifiers.
     
    30. A method for mapping signal elements to a first limited range of identifiers based on hash calculations, wherein said identifiers are used for addressing a first memory, characterized by:

    - assigning identifiers within the first limited range to an additional intermediate memory (40; 140) of a second larger range, thus emulating a larger virtual space of identifiers;

    - calculating, for each one of a plurality of signal elements, a hash value based on at least part of the signal element for addressing the intermediate memory (40; 140) to access an identifier, which in turn works as an address for access to said first memory,

    thereby reducing the risk for different signal elements being mapped to the same identifier.
     
    31. The method according to claim 30,
    characterized by detecting and handling a clash in the virtual space of identifiers.
     
    32. The method according to claim 31,
    characterized in that said clash detecting and handling step comprises the steps of:

    - detecting the mapping of a new signal element to the same identifier as a different and previously mapped signal element based on a comparison of the hash value associated with the new signal element and a hash value associated with the already mapped signal element; and

    - using the identifier for the new signal element in response to detection of such a mapping.


     
    33. The method according to any of the claims 30 to 32,
    characterized in that identifiers within the first limited range are cyclically assigned to the intermediate memory (40; 140).
     
    34. The method according to any of the claims 30 to 33,
    characterized in that said signal elements are packet headers and said identifiers are context identifiers, and the hash value is calculated based on at least one header field specified as no-change according to header compression standards.
     
    35. The method according to any of the claims 30 to 33,
    characterized in that said signal elements are memory addresses and said identifiers are cache line identifiers, and the hash value is calculated based on at least part of the memory address.
     
    36. The method according to any of the claims 30 to 33, characterized in that said signal elements are incoming packets and said identifiers are context identifiers, and said calculating steps includes calculating, for each of said incoming packets, a hash value based on those parts of the packet header that do not change between successive packets in a packet stream for addressing the intermediate memory (40) to access a context identifier,
    thereby reducing the risk for packet headers of different packet streams being mapped to the same context identifier.
     
    37. The method according to claim 36,
    characterized by detecting and handling a clash in the virtual space of context identifiers.
     
    38. The method according to claim 37,
    characterized in that said clash detecting and handling step comprises the steps of:

    - comparing, for an incoming packet belonging to a new packet stream, the calculated hash value for the incoming packet with a hash value associated with a header context stored in a context memory (12/22) at a location corresponding to the context identifier accessed from the intermediate memory by means of the calculated hash value;

    - allowing, in response to a match in the comparison due to clashing, the context identifier accessed from the intermediate memory to represent the incoming packet and the new packet stream; and

    - updating the context memory by storing the context-forming part of the packet header of the incoming packet at the location corresponding to the accessed context identifier, and associating the corresponding hash value with the stored header context.


     
    39. The method according to claim 38,
    characterized by updating, in response to a mismatch in the comparison, the accessed context identifier in the intermediate memory (40) by the oldest assigned context identifier, allowing the oldest assigned context identifier to represent the incoming packet header.
     
    40. The method according to any of the claims 36 to 39,
    characterized in that context identifiers within the first limited range are cyclically assigned to the intermediate memory to represent new packet streams.
     
    41. The method according to claim 40,
    characterized by skipping a context identifier in the cyclic assignment of context identifiers if the context identifier is detected as active.
     
    42. The method according to claim 38,
    characterized by updating, in response to a mismatch in the comparison, the accessed context identifier in the intermediate memory by the least recently used context identifier, allowing this context identifier to represent the packet header.
     
    43. The method according to any of the claims 36 to 38,
    characterized by assigning the least recently used context identifier to the intermediate memory to represent a packet belonging to a new packet stream.
     
    44. The method according to claim 42 or 43,
    characterized by arranging context identifiers within the first limited range in a sorted list (50) according to their use for representing packet streams with the most recently used context identifiers at the end of the list, wherein the context identifier at the head of the list is used as the least recently used context identifier.
     
    45. The method according to any of the claims 30 to 33, characterized in that said signal elements are memory addresses and said identifiers are cache line identifiers, and said calculating step includes calculating, for each of said memory addresses, a hash value based on at least part of the memory address for addressing the intermediate memory (140) to access a cache line identifier,
    thereby reducing the risk for different memory addresses being mapped to the same cache line identifier.
     
    46. The method according to claim 45,
    characterized by detecting and handling a clash in the virtual space of cache line identifiers.
     
    47. The method according to claim 46,
    characterized in that said clash detecting and handling step comprises the steps of:

    - comparing, for a new memory address, the calculated hash value of the memory address with a hash value associated with a tag stored in a cache memory line that corresponds to the cache line identifier accessed from the intermediate memory (140) by means of the calculated hash value;

    - allowing, in response to a match in the comparison due to clashing, access to the cache memory line identified by the accessed cache line identifier; and

    - updating the cache memory line identified by the accessed cache line identifier by storing the tag of the new memory address, and for associating the corresponding hash value to the stored tag.


     
    48. The method according to claim 47,
    characterized by updating, in response to a mismatch in the comparison, the accessed cache line identifier in the intermediate memory (140) by the oldest assigned cache line identifier, allowing access to the cache memory line identified by the oldest assigned cache line identifier.
     
    49. The method according to any of the claims 45 to 48,
    characterized in that cache line identifiers within the first limited range are cyclically assigned to the intermediate memory (140).
     
    50. The method according to claim 49,
    characterized by skipping a cache line identifier in the cyclic assignment of cache line identifiers if the cache line identifier is detected as active.
     
    51. The method according to claim 47,
    characterized by updating, in response to a mismatch in the comparison, the accessed cache line identifier in the intermediate memory by the least recently used cache line identifier, allowing access to the cache memory line identified by this cache line identifier.
     
    52. The method according to any of the claims 45 to 47,
    characterized by assigning the least recently used cache line identifier to the intermediate memory to allow access to the corresponding cache memory line.
     
    53. The method according to claim 51 or 52,
    characterized by arranging cache line identifiers within the first limited range in a sorted list (150) according to their use, with the most recently used cache line identifiers at the end of the list, wherein the cache line identifier at the head of the list is used as the least recently used cache line identifier.
     
    54. The method according to claim 30,
    characterized in that said first memory is a context memory or a cache memory.
     
    55. The method according to claim 30,
    characterized in that said first memory is a context memory and said identifiers are context identifiers.
     
    56. The method according to claim 30,
    characterized in that said first memory is a cache memory and said identifiers are cache line identifiers.
     


    Ansprüche

    1. System zum Abbilden von Signalelementen auf einen ersten, begrenzten Bereich von Identifikatoren mittels eines Hash-Codierers (30; 130), wobei die Identifikatoren zum Adressieren eines ersten Speichers verwendet werden, dadurch gekennzeichnet, dass
    das System einen zusätzlichen Zwischenspeicher (40; 140) eines zweiten, größeren Bereichs zum Speichern von Identifikatoren umfasst, die von dem ersten, begrenzten Bereich zugeordnet sind, wodurch ein größerer, virtueller Raum von Identifikatoren emuliert wird, und
    der Hash-Codierer (30; 130) zum Berechnen eines Hash-Wertes für jedes einer Vielzahl von Signalelementen basierend auf zumindest einem Teil des Signalelements zum Adressieren des Zwischenspeichers (40; 140) angepasst ist, um auf einen Identifikator zuzugreifen, der wiederum als eine Adresse zum Zugriff auf den ersten Speicher funktioniert,
    wodurch das Risiko für Zusammenstöße vermindert wird.
     
    2. System nach Anspruch 1,
    gekennzeichnet durch eine Vorrichtung zum Erfassen und Handhaben eines Zusammenstoßes in dem virtuellen Raum von Identifikatoren.
     
    3. System nach Anspruch 2,
    dadurch gekennzeichnet, dass die Zusammenstoß-erfassende und -handhabende Vorrichtung umfasst:

    - eine Vorrichtung zum Erfassen der Abbildung eines neuen Signalelementes auf den gleichen Identifikator wie ein unterschiedliches und zuvor abgebildetes Signalelement basierend auf einem Vergleich des Hash-Wertes, der mit dem neuen Signalelement verknüpft ist und eines Hash-Wertes, der mit dem bereits abgebildeten Signalelement verknüpft ist; und

    - eine Vorrichtung zum Verwenden des Identifikators für das neue Signalelement in Reaktion auf eine Erfassung einer derartigen Abbildung.


     
    4. System nach einem der Ansprüche 1 bis 3, gekennzeichnet durch eine Vorrichtung zum zyklischen Zuordnen von Identifikatoren innerhalb des ersten begrenzten Bereichs zu dem Zwischenspeicher (40; 140).
     
    5. System nach einem der Ansprüche 1 bis 4,
    dadurch gekennzeichnet, dass die Signalelemente Paket-Header sind und die Identifikatoren Kontext-Identifikatoren sind und der Hash-Wert basierend auf zumindest einem Header-Feld berechnet wird, das als Nicht-Änderung (No-Change) gemäß Header-Komprimierungsstandards spezifiziert ist.
     
    6. System nach einem der Ansprüche 1 bis 4,
    dadurch gekennzeichnet, dass die Signalelemente Speicheradressen sind und die Identifikatoren Cache-Zeilenidentifikatoren sind und der Hash-Wert basierend auf zumindest einem Teil der Speicheradresse berechnet wird.
     
    7. System nach einem der Ansprüche 1 bis 4, dadurch gekennzeichnet, dass die Signalelemente eingehende Pakete sind und die Identifikatoren Kontext-Identifikatoren sind und der Hash-Codierer (30) betriebsfähig zum Berechnen eines Hash-Wertes für jedes einer Vielzahl der eingehenden Pakete basierend auf jenen Teilen des Paket-Headers ist, die sich zwischen aufeinander folgenden Paketen in einem Paketstrom zum Adressieren des Zwischenspeichers (40) nicht ändern, um auf einen Kontext-Identifikator zuzugreifen,
    wodurch das Risiko für Paket-Header von unterschiedlichen Paketströmen verringert wird, die auf dem gleichen Kontext-Identifikator abgebildet werden.
     
    8. System nach Anspruch 7,
    gekennzeichnet durch eine Vorrichtung zum Erfassen und Handhaben eines Zusammenstoßes in dem virtuellen Raum von Kontext-Identifikatoren.
     
    9. System nach Anspruch 8,
    dadurch gekennzeichnet, dass die Zusammenstoß-erfassende und -handhabende Vorrichtung umfasst:

    - eine Vorrichtung zum Vergleichen für ein eingehendes Paket, das zu einem neuen Paketstrom gehört, des berechneten Hash-Wertes für das eingehende Paket mit einem Hash-Wert, der mit einem Header-Kontext verknüpft ist, der in einem Kontextspeicher (12/22) an einem Ort entsprechend dem Kontext-Identifikator gespeichert wird, auf den von dem Zwischenspeicher (40) mittels des berechneten Hash-Wertes aus zugegriffen wird;

    - eine Vorrichtung zum Zulassen in Reaktion auf eine Übereinstimmung in dem Vergleich aufgrund eines Zusammenstoßes, dass der Kontext-Identifikator, auf den von dem Zwischenspeicher (40) aus zugegriffen wird, den neuen Paketdatenstrom darstellt; und

    - eine Vorrichtung zum Aktualisieren des Kontextspeichers (12/22) durch Speichern des Kontext-bildenden Teils des Paket-Headers des eingehenden Paketes an einem Ort entsprechend dem zugegriffenen Kontext-Identifikator und zum Verknüpfen des entsprechenden Hash-Wertes mit dem gespeicherten Header-Kontext.


     
    10. System nach Anspruch 9, gekennzeichnet durch:

    - eine Vorrichtung zum Aktualisieren in Reaktion auf eine Fehlübereinstimmung in dem Vergleich des zugegriffenen Kontext-Identifikators in dem Zwischenspeicher (40) durch den ältesten, zugeordneten Kontext-Identifikator; und

    - eine Vorrichtung zum Zulassen in Reaktion auf eine Fehlübereinstimmung in dem Vergleich, dass der älteste zugeordnete Kontext-Identifikator den Paket-Header und den entsprechenden Paketstrom darstellt.


     
    11. System nach einem der Ansprüche 7 bis 10, gekennzeichnet durch eine Vorrichtung zum zyklischen Zuordnen von Kontext-Identifikatoren innerhalb des ersten begrenzten Bereichs zu dem Zwischenspeicher (40), um neue Paketströme darzustellen.
     
    12. System nach Anspruch 11, gekennzeichnet durch eine Vorrichtung zum Auslassen eines Kontext-Identifikators in der zyklischen Zuordnung von Kontext-Identifikatoren, falls der Kontext-Identifikator als aktiv erfasst wird.
     
    13. System nach Anspruch 9, gekennzeichnet durch:

    - eine Vorrichtung zum Aktualisieren in Reaktion auf eine Fehlübereinstimmung in dem Vergleich des zugegriffenen Kontext-Identifikators in dem Zwischenspeicher durch den am längsten nicht verwendeten Kontext-Identifikator; und

    - eine Vorrichtung zum Zulassen in Reaktion auf eine Fehlübereinstimmung in dem Vergleich, dass der am längsten nicht verwendete Kontext-Identifikator den Paket-Header und den entsprechenden Paketstrom darstellt.


     
    14. System nach einem der Ansprüche 7 bis 9,
    gekennzeichnet durch eine Vorrichtung zum Zuordnen des am längsten nicht verwendeten Kontext-Identifikators zu dem Zwischenspeicher, um ein Paket darzustellen, das zu einem neuen Paketstrom gehört.
     
    15. System nach Anspruch 13 oder 14,
    gekennzeichnet durch eine Vorrichtung zum Anordnen von Kontext-Identifikatoren innerhalb des ersten begrenzten Bereichs in einer sortierten Liste (40) gemäß ihrer Verwendung zum Darstellen von Paketströmen mit den zuletzt verwendeten Kontext-Identifikatoren an dem Ende der Liste, wobei der Kontext-Identifikator an dem Kopf der Liste als am längsten nicht verwendeter Kontext-Identifikator verwendet wird.
     
    16. System nach Anspruch 7, gekennzeichnet durch:

    - eine Vorrichtung zum Adressieren eines Kontextspeichers (12/22) basierend auf dem zugegriffenen Kontext-Identifikator, um einen entsprechenden Header-Kontext zu erhalten;

    - eine Vorrichtung zum Durchführen eines Vergleichs zwischen dem Kontext-bildenden Teil des gegenwärtigen Paket-Headers und dem erhaltenen Header-Kontext;

    - eine Vorrichtung zum Zulassen in Reaktion auf eine Übereinstimmung in dem Vergleich, dass der Kontext-Identifikator den Paket-Header und den entsprechenden Paketstrom darstellt;

    - eine Vorrichtung zum, in Reaktion auf eine Fehlübereinstimmung in dem Vergleich:

    - Durchführen eines weiteren Vergleichs zwischen dem berechneten Hash-Wert des gegenwärtigen Paket-Headers und eines Hash-Wertes, der mit dem erhaltenen Header-Kontext in dem Kontextspeicher verknüpft ist; und

    - in Reaktion auf eine Übereinstimmung in dem weiteren Vergleich aufgrund eines Zusammenstoßens, Zulassen, dass der zugegriffene Kontext-Identifikator den Paket-Header und den entsprechenden Paketstrom darstellt;

    - in Reaktion auf eine Fehlübereinstimmung in dem weiteren Vergleich, Aktualisieren des zugegriffenen Kontext-Identifikators in dem Zwischenspeicher durch den ältesten, zugeordneten Kontext-Identifikator oder den am längsten nicht verwendeten Kontext-Identifikator, Zulassen, dass dieser Kontext-Identifikator, den Paket-Header und den entsprechenden Paketstrom darstellt; und

    - Aktualisieren des Kontextspeichers durch Speichern des Kontext-bildenden Teils des gegenwärtigen Paket-Headers an dem Speicherort entsprechend dem Kontext-Identifikator, der den Paket-Header darstellen darf, und Verknüpfen des entsprechenden Hash-Wertes mit dem Kontext-bildenden Headerteil.


     
    17. System nach einem der Ansprüche 1 bis 4, dadurch gekennzeichnet, dass Signalelement Speicheradressen sind und die Identifikatoren Cache-Zeilenidentifikatoren sind, und der Hash-Codierer (130) betriebsfähig zum Berechnen eines Hash-Wertes für jede der Speicheradressen basierend auf zumindest einem Teil der Speicheradresse zum Adressieren des Zwischenspeichers (140) ist, um auf einen Cache-Zeilenidentifikator zuzugreifen,
    wodurch das Risiko für unterschiedliche Speicheradressen verringert wird, die auf den gleichen Cache-Zeilenidentifikator abgebildet werden.
     
    18. System nach Anspruch 17,
    gekennzeichnet durch eine Vorrichtung zum Erfassen und Handhaben eines Zusammenstoßes in dem virtuellen Raum von Cache-Zeilenidentifikatoren.
     
    19. System nach Anspruch 18,
    dadurch gekennzeichnet, dass die Zusammenstoß-erfassende und -handhabende Vorrichtung umfasst:

    - eine Vorrichtung zum Vergleichen für ein neue Speicheradresse des berechneten Hash-Wertes der Speicheradresse mit einem Hash-Wert, der mit einem Etikett (Tag) verknüpft ist, das in einer Cache-Speicherzeile gespeichert ist, die dem Cache-Zeilenidentifikator entspricht, auf den von dem Zwischenspeicher (140) mittels des berechneten Hash-Wertes aus zugegriffen wird;

    - eine Vorrichtung zum Zulassen in Reaktion auf eine Übereinstimmung in dem Vergleich aufgrund eines Zusammenstoßes eines Zugriffs auf die Cache-Speicherzeile, die durch den zugegriffenen Cache-Zeilenidentifikator identifiziert wird; und

    - eine Vorrichtung zum Aktualisieren der Cache-Speicherzeile, die von dem zugegriffenen Cache-Zeilenidentifikator identifiziert wird, durch Speichern des Etiketts der neuen Speicheradresse und zum Verknüpfen des entsprechenden Hash-Wertes mit dem gespeicherten Etikett.


     
    20. System nach Anspruch 19, gekennzeichnet durch:

    - eine Vorrichtung zum Aktualisieren in Reaktion auf eine Fehlübereinstimmung in dem Vergleich des zugegriffenen Cache-Zeilenidentifikators in dem Zwischenspeicher (140) durch den ältesten, zugeordneten Cache-Zeilenidentifikator; und

    - eine Vorrichtung zum Zulassen in Reaktion auf eine Fehlübereinstimmung in dem Vergleich eines Zugriffs auf die Cache-Speicherzeile, die von dem ältesten, zugeordneten Cache-Zeilenidentifikator identifiziert wird.


     
    21. System nach einem der Ansprüche 17 bis 20,
    gekennzeichnet durch eine Vorrichtung zum zyklischen Zuordnen von Cache-Zeilenidentifikatoren innerhalb des ersten begrenzten Bereiches zu dem Zwischenspeicher (140).
     
    22. System nach Anspruch 21,
    gekennzeichnet durch eine Vorrichtung zum Auslassen eines Cache-Zeilenidentifikators bei der zyklischen Zuordnung von Cache-Zeilenidentifikatoren, falls der Cache-Zeilenidentifikator als aktiv erfasst wird.
     
    23. System nach Anspruch 19, gekennzeichnet durch:

    - eine Vorrichtung zum Aktualisieren in Reaktion auf eine Fehlübereinstimmung in dem Vergleich des zugegriffenen Cache-Zeilenidentifikators in dem Zwischenspeicher durch den am längsten nicht verwendeten Cache-Zeilenidentifikator; und

    - eine Vorrichtung zum Zulassen in Reaktion auf eine Fehlübereinstimmung in dem Vergleich eines Zugriffs auf die Cache-Speicherzeile, die von dem am längsten nicht verwendeten Cache-Zeilenidentifikator identifiziert wird.


     
    24. System nach einem der Ansprüche 17 bis 19,
    gekennzeichnet durch eine Vorrichtung zum Zuordnen des am längsten nicht verwendeten Cache-Zeilenidentifikators zu dem Zwischenspeicher, um einen Zugriff auf die entsprechende Cache-Speicherzeile zuzulassen.
     
    25. System nach Anspruch 23 oder 24,
    gekennzeichnet durch eine Vorrichtung zum Anordnen von Cache-Zeilenidentifikatoren innerhalb des ersten begrenzten Bereichs in einer sortierten Liste (150) gemäß ihrer Verwendung, mit den zuletzt verwendeten Cache-Zeilenidentifikatoren an dem Ende der Liste, wobei der Cache-Zeilenidentifikator an dem Kopf der Liste als der am längsten nicht verwendet Cache-Zeilenidentifikator verwendet wird.
     
    26. System nach Anspruch 17, gekennzeichnet durch:

    - eine Vorrichtung zum Erhalten von Etikett-Information aus einer Cache-Speicherzeile, die von dem zugegriffenen Cache-Zeilenidentifikator identifiziert wird;

    - eine Vorrichtung zum Durchführen eines Vergleichs zwischen dem Etikett der Speicheradresse und der erhaltenen Etikett-Information;

    - eine Vorrichtung zum in Reaktion auf eine Übereinstimmung in dem Vergleich Zulassen eines Zugriffs auf die Cache-Speicherzeile, die von dem zugegriffenen Cache-Zeilenidentifikator identifiziert wird;

    - eine Vorrichtung zum in Reaktion auf eine Fehlübereinstimmung in dem Vergleich:

    - Durchführen eines weiteren Vergleichs zwischen dem berechneten Hash-Wert der Speicheradresse und einem Hash-Wert, der mit der erhaltenen Etikett-Information verknüpft ist; und

    - in Reaktion auf eine Übereinstimmung in dem weiteren Vergleich aufgrund eines Zusammenstoßens Zulassen eines Zugriffs auf die Cache-Speicherzeile, die von dem zugegriffenen Cache-Zeilenidentifikator identifiziert wird;

    - in Reaktion auf eine Fehlübereinstimmung in dem weiteren Vergleich Aktualisieren des zugegriffenen Cache-Zeilenidentifikators in dem Zwischenspeicher (140) durch den ältesten zugeordneten Cache-Zeilenidentifikator oder den am wenigstens nicht verwendeten Cache-Zeilenidentifikator, Zulassen eines Zugriffs auf die Cache-Speicherzeile, die von diesem Cache-Zeilenidentifikator identifiziert wird; und

    - Aktualisieren der zugegriffenen Cache-Speicherzeile durch Speichern des Etiketts der Speicheradresse und Verknüpfen des entsprechenden Hash-Wertes mit dem gespeicherten Etikett.


     
    27. System nach Anspruch 1,
    dadurch gekennzeichnet, dass der erste Speicher ein Kontextspeicher oder ein Cache-Speicher ist.
     
    28. System nach Anspruch 1,
    dadurch gekennzeichnet, dass der erste Speicher ein Kontextspeicher ist und die Identifikatoren Kontext-Identifikatoren sind.
     
    29. System nach Anspruch 1,
    dadurch gekennzeichnet, dass der erste Speicher ein Cache-Speicher ist und die Identifikatoren Cache-Zeilenidentifikatoren sind.
     
    30. Verfahren zum Abbilden von Signalelementen auf einen ersten begrenzten Bereich von Identifikatoren basierend auf Hash-Berechnungen, wobei die Identifikatoren zum Adressieren eines ersten Speichers verwendet werden,
    gekennzeichnet durch:

    - Zuordnen von Identifikatoren innerhalb des ersten begrenzten Bereichs zu einem zusätzlichen Zwischenspeicher (40; 140) eines zweiten, größeren Bereichs, wodurch ein größerer virtuellen Raum von Identifikatoren emuliert wird;

    - Berechnen für jedes einer Vielzahl von Signalelementen eines Hash-Wertes basierend auf zumindest einem Teil des Signalelements zum Adressieren des Zwischenspeichers (40; 140), um auf einen Identifikator zuzugreifen, der wiederum als eine Adresse zum Zugriff auf den ersten Speicher funktioniert,

    wodurch das Risiko für unterschiedliche Signalelemente verringert wird, die auf dem gleichen Identifikator abgebildet werden.
     
    31. Verfahren nach Anspruch 30,
    gekennzeichnet durch Erfassen und Handhaben eines Zusammenstoßes in dem virtuellen Raum von Identifikatoren.
     
    32. Verfahren nach Anspruch 31,
    dadurch gekennzeichnet, dass der Zusammenstoß-erfassende und -handhabende Schritt die Schritte umfasst:

    - Erfassen der Abbildung eines neuen Signalelementes auf den gleichen Identifikator wie ein unterschiedliches und zuvor abgebildetes Signalelement basierend auf einem Vergleich des Hash-Wertes, der mit dem neuen Signalelement verknüpft ist und eines Hash-Wertes, der mit dem bereits abgebildeten Signalelement verknüpft ist; und

    - Verwenden des Identifikators für das neue Signalelement in Reaktion auf eine Erfassung einer derartigen Abbildung.


     
    33. Verfahren nach einem der Ansprüche 30 bis 32,
    dadurch gekennzeichnet, dass Identifikatoren innerhalb des ersten, begrenzten Bereichs zyklisch zu dem Zwischenspeicher (40; 140) zugeordnet sind.
     
    34. Verfahren nach einem der Ansprüche 30 bis 33,
    dadurch gekennzeichnet, dass die Signalelemente Paket-Header sind und die Identifikatoren Kontext-Identifikatoren sind, und der Hash-Wert basierend auf zumindest einem Header-Feld berechnet wird, das als Nicht-Änderung (no-change) gemäß Header-Komprimierungsstandards spezifiziert ist.
     
    35. Verfahren nach einem der Ansprüche 30 bis 33,
    dadurch gekennzeichnet, dass die Signalelemente Speicheradressen sind und die Identifikatoren Cache-Zeilenidentifikatoren sind und der Hash-Wert basierend auf zumindest einem Teil der Spaltenadresse berechnet wird.
     
    36. Verfahren nach einem der Ansprüche 30 bis 33, dadurch gekennzeichnet, dass die Signalelemente eingehende Pakete sind und die Identifikatoren Kontext-Identifikatoren sind und der berechnete Schritt ein Berechnen für jedes der eingehenden Pakete eines Hash-Wertes basierend auf jenen Teilen des Paket-Headers einschließt, die sich zwischen aufeinander folgenden Paketen in einem Paketstrom zum Adressieren des Zwischenspeichers (40) nicht ändern, um auf einen Kontext-Identifikator zuzugreifen,
    wodurch das Risiko für Paket-Header von unterschiedlichen Paketströmen verringert wird, die auf dem gleichen Kontext-Identifikator abgebildet werden.
     
    37. Verfahren nach Anspruch 36,
    gekennzeichnet durch Erfassen und Handhaben eines Zusammenstoßes in dem virtuellen Raum von Kontext-Identifikatoren.
     
    38. Verfahren nach Anspruch 37,
    dadurch gekennzeichnet, dass der Zusammenstoß-erfassende und -handhabende Schritt die Schritte umfasst:

    - Vergleichen für ein eingehendes Paket, das zu einem neuen Paketstrom gehört, des berechneten Hash-Wertes für das eingehende Paket mit einem Hash-Wert, der mit einem Header-Kontext verknüpft ist, der in einem Kontextspeicher (12/22) an einem Ort entsprechend dem Kontext-Identifikator gespeichert ist, auf den von dem Zwischenspeicher mittels des berechneten Hash-Wertes zugegriffen wird;

    - Zulassen in Reaktion auf eine Übereinstimmung in dem Vergleich aufgrund eines Zusammenstoßens, dass der Kontext-Identifikator, auf den von dem Zwischenspeicher aus zugegriffen wird, das eingehende Paket und den neuen Paketstrom darstellt; und

    - Aktualisieren des Kontextspeichers durch Speichern des Kontext-bildenden Teils des Paket-Headers des eingehenden Paketes an dem Ort entsprechend dem zugegriffenen Kontext-Identifikator, und Verknüpfen des entsprechenden Hash-Wertes mit dem gespeicherten Header-Kontext.


     
    39. Verfahren nach Anspruch 38,
    gekennzeichnet durch Aktualisieren in Reaktion auf eine Fehlübereinstimmung in dem Vergleich des zugegriffenen Kontext-Identifikators in dem Zwischenspeicher (40) durch den ältesten zugeordneten Kontext-Identifikator, Zulassen, dass der älteste Kontext-Identifikator den eingehenden Paket-Header darstellt.
     
    40. Verfahren nach einem der Ansprüche 36 bis 39,
    dadurch gekennzeichnet, dass Kontext-Identifikatoren innerhalb des ersten begrenzten Bereichs zyklisch zu dem Zwischenspeicher zugeordnet werden, um neue Paketströme darzustellen.
     
    41. Verfahren nach Anspruch 40,
    gekennzeichnet durch Auslassen eines Kontext-Identifikators bei der zyklischen Zuordnung von Kontext-Identifikatoren, falls der Kontext-Identifikator als aktiv erfasst wird.
     
    42. Verfahren nach Anspruch 38,
    gekennzeichnet durch Aktualisieren in Reaktion auf eine Fehlübereinstimmung in dem Vergleich des zugegriffenen Kontext-Identifikators in dem Zwischenspeicher durch den am längsten nicht verwendeten Kontext-Identifikator, Zulassen dieses Kontext-Identifikators, um den Paket-Header darzustellen.
     
    43. Verfahren nach einem der Ansprüche 36 bis 38,
    gekennzeichnet durch Zuordnen des am längsten nicht verwendeten Kontext-Identifikators zu dem Zwischenspeicher, um ein Paket darzustellen, das zu einem neuen Datenstrom gehört.
     
    44. Verfahren nach Anspruch 42 oder 43,
    gekennzeichnet durch Anordnen von Kontext-Identifikatoren innerhalb des ersten begrenzten Bereichs in einer sortierten Liste gemäß ihrer Verwendung zum Darstellen von Paketströmen mit den zuletzt verwendeten Kontext-Identifikatoren an dem Ende der Liste, wobei der Kontext-Identifikator an dem Kopf der Liste als der am längsten nicht verwendete Kontext-Identifikator verwendet wird.
     
    45. Verfahren nach einem der Ansprüche 30 bis 33, dadurch gekennzeichnet, dass die Signalelemente Speicheradressen sind und die Identifikatoren Cache-Zeilenidentifikatoren sind und der berechnete Schritt ein Berechnen für jede der Speicheradressen eines Hash-Wertes basierend auf zumindest einem Teil der Speicheradresse zum Adressieren des Zwischenspeichers (140) einschließt, um auf einen Cache-Zeilenidentifikator zuzugreifen,
    wodurch das Risiko für unterschiedliche Speicheradressen verringert wird, die auf den gleichen Cache-Zeilenidentifikator abgebildet werden.
     
    46. Verfahren nach Anspruch 45,
    gekennzeichnet durch Erfassen und Handhaben eines Zusammenstoßes in dem virtuellen Raum von Cache-Zeilenidentifikatoren.
     
    47. Verfahren nach Anspruch 46,
    dadurch gekennzeichnet, dass der Zusammenstoß-erfassende und -handhabende Schritt die Schritte umfasst:

    - Vergleichen für eine neue Speicheradresse des berechneten Hash-Wertes der Speicheradresse mit einem Hash-Wert, der mit einem Etikett verknüpft ist, das in einer Cache-Speicherzeile gespeichert ist, die dem Cache-Zeilenidentifikator entspricht, auf den von dem Zwischenspeicher (140) mittels des berechneten Hash-Wertes aus zugegriffen wird;

    - Zulassen in Reaktion auf eine Übereinstimmung in dem Vergleich aufgrund eines Zusammenstoßes eines Zugriffs zu der Cache-Speicherzeile, die von dem zugegriffenen Cache-Zeilenidentifikator identifiziert wird; und

    - Aktualisieren der Cache-Speicherzeile, die von dem zugegriffenen Cache-Zeilenidentifikator identifiziert wird, durch Speichern des Etiketts der neuen Speicheradresse und zum Verknüpfen des entsprechenden Hash-Wertes mit dem gespeicherten Etikett.


     
    48. Verfahren nach Anspruch 47,
    gekennzeichnet durch Aktualisieren in Reaktion auf eine Fehlübereinstimmung in dem Vergleich des zugegriffenen Cache-Zeilenidentifikators in dem Zwischenspeicher (140) durch den ältesten zugeordneten Cache-Zeilenidentifikator, Zulassen eines Zugriffs auf die Cache-Speicherzeile, die durch den ältesten zugeordneten Cache-Zeilenidentifikator identifiziert wird.
     
    49. Verfahren nach einem der Ansprüche 45 bis 48,
    dadurch gekennzeichnet, dass Cache-Zeilenidentifikatoren innerhalb des ersten begrenzten Bereichs zyklisch zu dem Zwischenspeicher (140) zugeordnet werden.
     
    50. Verfahren nach Anspruch 49,
    gekennzeichnet durch Auslassen eines Cache-Zeilenidentifikators in der zyklischen Zuordnung von Cache-Zeilenidentifikatoren, falls der Cache-Zeilenidentifikator als aktiv erfasst wird.
     
    51. Verfahren nach Anspruch 47,
    gekennzeichnet durch Aktualisieren in Reaktion auf eine Fehlübereinstimmung in dem Vergleich des zugegriffenen Cache-Zeilenidentifikators in dem Zwischenspeicher durch den am längsten nicht verwendeten Cache-Zeilenidentifikator, Zulassen eines Zugriffs auf die Cache-Speicherzeile, die von diesem Cache-Zeilenidentifikator identifiziert wird.
     
    52. Verfahren nach einem der Ansprüche 45 bis 47,
    gekennzeichnet durch Zuordnen des am längsten nicht verwendeten Cache-Zeilenidentifikators zu dem Zwischenspeicher, um einen Zugriff auf die entsprechende Cache-Speicherzeile zu erlauben.
     
    53. Verfahren nach Anspruch 51 oder 52,
    gekennzeichnet durch Anordnen von Cache-Zeilenidentifikatoren innerhalb des ersten begrenzten Bereichs in einer sortierten Liste (150) gemäß ihrer Verwendung, mit den zuletzt verwendeten Cache-Zeilenidentifikatoren an dem Ende der Liste, wobei der Cache-Zeilenidentifikator an dem Kopf der Liste als der am längsten nicht verwendete Cache-Zeilenidentifikator verwendet wird.
     
    54. Verfahren nach Anspruch 30,
    dadurch gekennzeichnet, dass der erste Speicher ein Kontextspeicher oder ein Cache-Speicher ist.
     
    55. Verfahren nach Anspruch 30,
    dadurch gekennzeichnet, dass der erste Speicher ein Kontextspeicher ist und die Identifikatoren Kontext-Identifikatoren sind.
     
    56. Verfahren nach Anspruch 30, dadurch gekennzeichnet, dass der erste Speicher ein Cache-Speicher ist und die Identifikatoren Cache-Zeilenidentifikatoren sind.
     


    Revendications

    1. Système destiné à mapper des éléments de signal avec une première plage limitée d'identificateurs, à l'aide d'un codeur de hachage (30 ; 130), dans lequel lesdits identificateurs sont utilisés pour l'adressage d'une première mémoire, caractérisé en ce que :

    ledit système comprend une mémoire intermédiaire supplémentaire (40 ; 140) d'une seconde plage plus étendue, destinée à stocker des identificateurs attribués à partir de la première plage limitée, ce qui permet d'émuler un espace virtuel d'identificateurs plus étendu ; et

    ledit codeur de hachage (30 ; 130) est conçu pour calculer, pour chacun des éléments dans une pluralité d'éléments de signal, une valeur de hachage basée sur au moins une partie de l'élément de signal, destinée à l'adressage de la mémoire intermédiaire (40 ; 140) afin d'accéder à l'identificateur qui, à son tour, sert d'adresse pour accéder à ladite première mémoire,

    ce qui réduit le risque de conflits.


     
    2. Système selon la revendication 1, caractérisé par un moyen destiné à détecter et à traiter un conflit dans l'espace virtuel d'identificateurs.
     
    3. Système selon la revendication 2, caractérisé en ce que ledit moyen de détection et de traitement de conflits comprend :

    - un moyen destiné à détecter le mappage d'un nouvel élément de signal avec le même identificateur qu'un élément de signal différent mappé précédemment, sur la base d'une comparaison de la valeur de hachage associée au nouvel élément de signal et d'une valeur de hachage associée à l'élément de signal déjà mappé ; et

    - un moyen destiné à utiliser l'identificateur pour le nouvel élément de signal en réponse à la détection de ce mappage.


     
    4. Système selon l'une quelconque des revendications 1 à 3, caractérisé par un moyen destiné à attribuer cycliquement à la mémoire intermédiaire (40 ; 140) des identificateurs pris dans la première plage limitée.
     
    5. Système selon l'une quelconque des revendications 1 à 4, caractérisé en ce que lesdits éléments de signal sont des en-têtes de paquets et lesdits identificateurs sont des identificateurs de contexte, et en ce que la valeur de hachage est calculée sur la base d'au moins un champ d'entête spécifié comme sans changement selon les normes de compression des en-têtes.
     
    6. Système selon l'une quelconque des revendications 1 à 4, caractérisé en ce que lesdits éléments de signal sont des adresses de mémoire et lesdits identificateurs sont des identificateurs de ligne d'antémémoire, et en ce que la valeur de hachage est calculée sur au moins une partie de l'adresse de mémoire.
     
    7. Système selon l'une quelconque des revendications 1 à 4, caractérisé en ce que lesdits éléments de signal sont des paquets entrants et lesdits identificateurs sont des identificateurs de contexte, et en ce que ledit codeur de hachage (30) est en mesure de calculer, pour chaque paquet dans une pluralité desdits paquets entrants, une valeur de hachage basée sur les parties de l'en-tête de paquet qui ne changent pas entre des paquets successifs dans un flux de paquets, pour l'adressage de la mémoire intermédiaire (40) afin d'accéder à un identificateur de contexte,
    ce qui réduit le risque que des en-têtes de paquets de différents flux de paquets soient mappés avec le même identificateur de contexte.
     
    8. Système selon la revendication 7, caractérisé par un moyen destiné à détecter et traiter un conflit dans l'espace virtuel d'identificateurs de contexte.
     
    9. Système selon la revendication 8, caractérisé en ce que ledit moyen de détection et de traitement de conflits comprend :

    - un moyen destiné à comparer, pour un paquet entrant appartenant à un nouveau flux de paquets, la valeur de hachage calculée pour le paquet entrant avec une valeur de hachage associée à un contexte d'en-tête stocké dans une mémoire de contextes (12/22) dans une position correspondant à l'identificateur de contexte auquel il est accédé à partir de la mémoire intermédiaire (40) à l'aide de la valeur de hachage calculée ;

    - un moyen destiné, en réponse à une correspondance dans la comparaison en raison du conflit, à autoriser l'identificateur de contexte auquel il est accédé à partir de la mémoire intermédiaire (40) à représenter le nouveau flux de paquets ; et

    - un moyen destiné à mettre à jour la mémoire de contextes (12/22) en stockant la partie formant le contexte dans l'en-tête de paquet du paquet entrant dans une position correspondant à l'identificateur de contexte auquel il a été accédé et à associer la valeur de hachage correspondante avec le contexte d'en-tête stocké.


     
    10. Système selon la revendication 9, caractérisé par :

    - un moyen destiné, en réponse à une absence de correspondance dans la comparaison, à mettre à jour l'identificateur de contexte auquel il a été accédé dans la mémoire intermédiaire (40) à l'aide de l'identificateur de contexte attribué le plus ancien ; et

    - un moyen destiné, en réponse à une absence de correspondance dans la comparaison, à autoriser l'identificateur de contexte attribué le plus ancien à représenter l'en-tête de paquet et le flux de paquets correspondant.


     
    11. Système selon l'une quelconque des revendications 7 à 10, caractérisé par un moyen destiné à attribuer cycliquement à la mémoire intermédiaire (40) des identificateurs de contexte pris dans la première plage limitée pour représenter de nouveaux flux de paquets.
     
    12. Système selon la revendication 11, caractérisé par un moyen destiné à passer un identificateur de contexte dans l'attribution cyclique d'identificateurs de contexte, si l'identificateur de contexte est détecté comme actif.
     
    13. Système selon la revendication 9, caractérisé par :

    - un moyen destiné, en réponse à une absence de correspondance dans la comparaison, à mettre à jour l'identificateur de contexte auquel il a été accédé dans la mémoire intermédiaire à l'aide de l'identificateur de contexte utilisé le moins récemment ; et

    - un moyen destiné, en réponse à une absence de correspondance dans la comparaison, à autoriser l'identificateur de contexte utilisé le moins récemment à représenter l'en-tête de paquet et le flux de paquets correspondant.


     
    14. Système selon l'une quelconque des revendications 7 à 9, caractérisé par un moyen destiné à attribuer l'identificateur de contexte utilisé le moins récemment à la mémoire intermédiaire pour représenter un paquet appartenant à un nouveau flux de paquets.
     
    15. Système selon la revendication 13 ou 14, caractérisé par un moyen destiné à agencer des identificateurs de contexte dans la première plage limitée sous la forme d'une liste triée (50) en fonction de leur utilisation pour la représentation de flux de paquets, les identificateurs de contexte utilisés le plus récemment se trouvant à la fin de la liste, dans lequel l'identificateur de contexte en tête de la liste est utilisé comme identificateur de contexte utilisé le moins récemment.
     
    16. Système selon la revendication 7, caractérisé par :

    - un moyen destiné à adresser une mémoire de contextes (12/22) sur la base de l'identificateur de contexte auquel il a été accédé, afin d'obtenir un contexte d'en-tête correspondant ;

    - un moyen destiné à effectuer une comparaison entre la partie de l'en-tête du paquet courant qui forme le contexte et le contexte d'en-tête obtenu ;

    - un moyen destiné, en cas de correspondance dans la comparaison, à autoriser l'identificateur de contexte à représenter l'en-tête de paquet et le flux de paquets correspondant ;

    - un moyen destiné à, en cas de absence de correspondance dans la comparaison :

    - effectuer une nouvelle comparaison entre la valeur de hachage calculée de l'en-tête du paquet courant et une valeur de hachage associée au contexte d'en-tête obtenu dans la mémoire de contextes ; et

    - en réponse à une correspondance dans la nouvelle comparaison en raison du conflit, autoriser l'identificateur de contexte auquel il a été accédé à représenter l'en-tête de paquet et le flux de paquets correspondant ;

    - en réponse à une absence de correspondance dans la nouvelle comparaison, mettre à jour l'identificateur de contexte auquel il a été accédé dans la mémoire intermédiaire à l'aide de l'identificateur de contexte attribué le plus ancien ou l'identificateur de contexte utilisé le moins récemment, autoriser cet identificateur de contexte à représenter l'en-tête de paquet et le flux de paquets correspondant ; et

    - mettre à jour la mémoire de contextes en stockant la partie de l'en-tête du paquet courant qui forme le contexte dans la position de mémoire correspondant à l'identificateur de contexte autorisé à représenter l'en-tête de paquet, et associer la valeur de hachage correspondante à la partie de l'en-tête qui forme le contexte.


     
    17. Système selon l'une quelconque des revendications 1 à 4, caractérisé en ce que lesdits éléments de signal sont des adresses de mémoire et lesdits identificateurs sont des identificateurs de ligne d'antémémoire, et en ce que ledit codeur de hachage (130) est en mesure de calculer, pour chacune desdites adresses de mémoire, une valeur de hachage sur la base d'au moins une partie de l'adresse de mémoire, pour l'adressage de la mémoire intermédiaire (140) afin d'accéder à un identificateur de ligne d'antémémoire,
    ce qui réduit le risque que différentes adresses de mémoire soient mappées avec le même identificateur de ligne d'antémémoire.
     
    18. Système selon la revendication 17, caractérisé par un moyen destiné à détecter et traiter un conflit dans l'espace virtuel des identificateurs de ligne d'antémémoire.
     
    19. Système selon la revendication 18, caractérisé en ce que ledit moyen de détection et de traitement de conflits comprend :

    - un moyen destiné à comparer, pour une nouvelle adresse de mémoire, la valeur de hachage calculée pour l'adresse de mémoire avec une valeur de hachage associée à une balise stockée dans une ligne d'antémémoire qui correspond à l'identificateur de ligne d'antémémoire auquel il a été accédé depuis la mémoire intermédiaire (140) à l'aide de la valeur de hachage calculée ;

    - un moyen destiné, en réponse à une correspondance dans la comparaison en raison du conflit, à autoriser l'accès à la ligne d'antémémoire identifiée par l'identificateur de ligne d'antémémoire auquel il a été accédé ; et

    - un moyen destiné à mettre à jour la ligne d'antémémoire identifiée par l'identificateur de ligne d'antémémoire auquel il a été accédé en stockant la balise de la nouvelle adresse de mémoire, et à associer la valeur de hachage correspondante à la balise stockée.


     
    20. Système selon la revendication 19, caractérisé par :

    - un moyen destiné, en réponse à une absence de correspondance dans la comparaison, à mettre à jour l'identificateur de ligne d'antémémoire auquel il a été accédé dans la mémoire intermédiaire (140) à l'aide de l'identificateur de ligne d'antémémoire attribué le plus ancien ; et

    - un moyen destiné, en réponse à une absence de correspondance dans la comparaison, à autoriser l'accès à la ligne d'antémémoire identifiée par l'identificateur de ligne d'antémémoire attribué le plus ancien.


     
    21. Système selon l'une quelconque des revendications 17 à 20, caractérisé par un moyen destiné à attribuer cycliquement à la mémoire intermédiaire (140) des identificateurs de ligne d'antémémoire de la première plage limitée.
     
    22. Système selon la revendication 21, caractérisé par un moyen destiné à passer un identificateur de ligne d'antémémoire, dans l'attribution cyclique des identificateurs de ligne d'antémémoire, si l'identificateur de ligne d'antémémoire est détecté comme actif.
     
    23. Système selon la revendication 19, caractérisé par :

    - un moyen destiné, en réponse à une absence de correspondance dans la comparaison, à mettre à jour l'identificateur de ligne d'antémémoire auquel il a été accédé dans la mémoire intermédiaire à l'aide de l'identificateur de ligne d'antémémoire utilisé le plus récemment ; et

    - un moyen destiné, en réponse à une absence de correspondance dans la comparaison, à autoriser l'accès à la ligne d'antémémoire identifiée par l'identificateur de ligne d'antémémoire utilisé le moins récemment.


     
    24. Système selon l'une quelconque des revendications 17 à 19, caractérisé par un moyen destiné à attribuer à la mémoire intermédiaire l'identificateur de ligne d'antémémoire utilisé le moins récemment pour permettre l'accès à la ligne d'antémémoire correspondante.
     
    25. Système selon la revendication 23 ou 24, caractérisé par un moyen destiné à agencer des identificateurs de ligne d'antémémoire dans la première plage limitée sous la forme d'une liste triée (150) en fonction de leur utilisation, les identificateurs de ligne d'antémémoire utilisés le plus récemment se trouvant à la fin de la liste, dans lequel l'identificateur de ligne d'antémémoire en tête de la liste est utilisé comme identificateur de ligne d'antémémoire utilisé le moins récemment.
     
    26. Système selon la revendication 17, caractérisé par :

    - un moyen destiné à obtenir des informations de balise d'une ligne d'antémémoire identifiée par l'identificateur de ligne d'antémémoire auquel il a été accédé ;

    - un moyen destiné à effectuer une comparaison entre la balise de l'adresse de mémoire et les informations de balise obtenues ;

    - un moyen destiné, en réponse à une correspondance dans la comparaison, à autoriser l'accès à la ligne d'antémémoire identifiée par l'identificateur de ligne d'antémémoire auquel il a été accédé ;

    - un moyen destiné à, en réponse à une absence de correspondance dans la comparaison :

    - effectuer une nouvelle comparaison entre la valeur de hachage calculée de l'adresse de mémoire et une valeur de hachage associée aux informations de balise obtenues ; et

    - en réponse à une correspondance dans la nouvelle comparaison en raison du conflit, autoriser l'accès à la ligne d'antémémoire identifiée par l'identificateur de ligne d'antémémoire auquel il a été accédé ;

    - en réponse à une absence de correspondance dans la nouvelle comparaison, mettre à jour l'identificateur de ligne d'antémémoire auquel il a été accédé dans la mémoire intermédiaire (140) à l'aide de l'identificateur de ligne d'antémémoire attribué le plus ancien ou l'identificateur de ligne d'antémémoire utilisé le moins récemment, autoriser l'accès à la ligne d'antémémoire identifiée par cet identificateur de ligne d'antémémoire ; et

    - mettre à jour la ligne d'antémémoire à laquelle il a été accédé en stockant la balise de l'adresse de mémoire et associer la valeur de hachage correspondante à la balise stockée.


     
    27. Système selon la revendication 1, caractérisé en ce que ladite première mémoire est une mémoire de contextes ou une antémémoire.
     
    28. Système selon la revendication 1, caractérisé en ce que ladite première mémoire est une mémoire de contextes et lesdits identificateurs sont des identificateurs de contextes.
     
    29. Système selon la revendication 1, caractérisé en ce que ladite première mémoire est une antémémoire et lesdits identificateurs sont des identificateurs de ligne d'antémémoire.
     
    30. Procédé destiné à mapper des éléments de signal avec une première plage limitée d'identificateurs, sur la base de calculs de hachages, dans lequel lesdits identificateurs sont utilisés pour l'adressage d'une première mémoire, caractérisé par les étapes consistant à :

    - attribuer des identificateurs de la première plage limitée à une mémoire intermédiaire supplémentaire (40 ; 140) d'une seconde plage plus étendue, ce qui permet d'émuler un espace virtuel d'identificateurs plus étendu ;

    - calculer, pour chacun des éléments dans une pluralité d'éléments de signal, une valeur de hachage basée sur au moins une partie de l'élément de signal, destinée à l'adressage de la mémoire intermédiaire (40 ; 140) afin d'accéder à l'identificateur qui, à son tour, sert d'adresse pour accéder à ladite première mémoire,

    ce qui réduit le risque que différents éléments de signal soient mappés avec le même identificateur.
     
    31. Procédé selon la revendication 30, caractérisé par l'étape consistant à détecter et traiter un conflit dans l'espace virtuel d'identificateurs.
     
    32. Procédé selon la revendication 31, caractérisé en ce que ladite étape de détection et de traitement des conflits comprend les étapes consistant à :

    - détecter le mappage d'un nouvel élément de signal avec le même identificateur qu'un élément de signal différent mappé précédemment, sur la base d'une comparaison de la valeur de hachage associée au nouvel élément de signal et d'une valeur de hachage associée à l'élément de signal déjà mappé ; et

    - utiliser l'identificateur du nouvel élément de signal en réponse à la détection de ce mappage.


     
    33. Procédé selon l'une quelconque des revendications 30 à 32, caractérisé en ce que des identificateurs de la première plage limitée sont attribués cycliquement à la mémoire intermédiaire (40 ; 140).
     
    34. Procédé selon l'une quelconque des revendications 30 à 33, caractérisé en ce que lesdits éléments de signal sont des en-têtes de paquets et lesdits identificateurs sont des identificateurs de contexte, et en ce que la valeur de hachage est calculée sur la base d'au moins un champ d'entête spécifié comme sans changement selon les normes de compression des en-têtes.
     
    35. Procédé selon l'une quelconque des revendications 30 à 33, caractérisé en ce que lesdits éléments de signal sont des adresses de mémoire et lesdits identificateurs sont des identificateurs de ligne d'antémémoire, et en ce que la valeur de hachage est calculée sur au moins une partie de l'adresse de mémoire.
     
    36. Procédé selon l'une quelconque des revendications 30 à 33, caractérisé en ce que lesdits éléments de signal sont des paquets entrants et lesdits identificateurs sont des identificateurs de contexte, et en ce que lesdites étapes de calcul comprennent le calcul, pour chacun desdits paquets entrants, d'une valeur de hachage basée sur les parties de l'en-tête de paquet qui ne changent pas entre des paquets successifs dans un flux de paquets, pour l'adressage de la mémoire intermédiaire (40) afin d'accéder à un identificateur de contexte,
    ce qui réduit le risque que des en-têtes de paquets de différents flux de paquets soient mappés avec le même identificateur de contexte.
     
    37. Procédé selon la revendication 36, caractérisé par l'étape consistant à détecter et traiter un conflit dans l'espace virtuel d'identificateurs de contexte.
     
    38. Procédé selon la revendication 37, caractérisé en ce que ladite étape de détection et de traitement des conflits comprend les étapes consistant à :

    - comparer, pour un paquet entrant appartenant à un nouveau flux de paquets, la valeur de hachage calculée pour le paquet entrant avec une valeur de hachage associée à un contexte d'en-tête stocké dans une mémoire de contextes (12/22) dans une position correspondant à l'identificateur de contexte auquel il est accédé à partir de la mémoire intermédiaire (40) à l'aide de la valeur de hachage calculée ;

    - en réponse à une correspondance dans la comparaison en raison du conflit, autoriser l'identificateur de contexte auquel il est accédé à partir de la mémoire intermédiaire (40) à représenter le nouveau flux de paquets ; et

    - mettre à jour la mémoire de contextes en stockant la partie formant le contexte dans l'en-tête de paquet du paquet entrant dans la position correspondant à l'identificateur de contexte auquel il a été accédé, et associer la valeur de hachage correspondante avec le contexte d'en-tête stocké.


     
    39. Procédé selon la revendication 38, caractérisé par l'étape consistant à, en réponse à une absence de correspondance dans la comparaison, mettre à jour l'identificateur de contexte auquel il a été accédé dans la mémoire intermédiaire (40) à l'aide de l'identificateur de contexte attribué le plus ancien, et autoriser l'identificateur de contexte attribué le plus ancien à représenter l'en-tête de paquet entrant.
     
    40. Procédé selon l'une quelconque des revendications 36 à 39, caractérisé en ce que des identificateurs de contexte de la première plage limitée sont attribués cycliquement à la mémoire intermédiaire pour représenter de nouveaux flux de paquets.
     
    41. Procédé selon la revendication 40, caractérisé par l'étape consistant à passer un identificateur de contexte dans l'attribution cyclique des identificateurs de contexte si l'identificateur de contexte est détecté comme actif.
     
    42. Procédé selon la revendication 38, caractérisé par l'étape consistant à mettre à jour l'identificateur de contexte auquel il a été accédé dans la mémoire intermédiaire à l'aide de l'identificateur de contexte utilisé le moins récemment, et autoriser cet identificateur de contexte à représenter l'en-tête de paquet.
     
    43. Procédé selon l'une quelconque des revendications 36 à 38, caractérisé par l'étape consistant à attribuer l'identificateur de contexte utilisé le moins récemment à la mémoire intermédiaire pour représenter un paquet appartenant à un nouveau flux de paquets.
     
    44. Procédé selon la revendication 42 ou 43, caractérisé par l'étape consistant à agencer des identificateurs de contexte dans la première plage limitée sous la forme d'une liste triée (50) en fonction de leur utilisation pour la représentation de flux de paquets, les identificateurs de contexte utilisés le plus récemment se trouvant à la fin de la liste, dans lequel l'identificateur de contexte en tête de la liste est utilisé comme identificateur de contexte utilisé le moins récemment.
     
    45. Procédé selon l'une quelconque des revendications 30 à 33, caractérisé en ce que lesdits éléments de signal sont des adresses de mémoire et lesdits identificateurs sont des identificateurs de ligne d'antémémoire, et en ce que ladite étape de calcul comprend le calcul, pour chacune desdites adresses de mémoire, d'une valeur de hachage basée sur au moins une partie de l'adresse, pour l'adressage de la mémoire intermédiaire (140) afin d'accéder à un identificateur de ligne d'antémémoire,
    ce qui réduit le risque que des adresses de mémoire différentes soient mappées avec le même identificateur de ligne d'antémémoire.
     
    46. Procédé selon la revendication 45, caractérisé par l'étape consistant à détecter et à traiter un conflit dans l'espace virtuel d'identificateurs de ligne d'antémémoire.
     
    47. Procédé selon la revendication 46, caractérisé en ce que ladite étape de détection et de traitement des conflits comprend les étapes consistant à :

    - comparer, pour une nouvelle adresse de mémoire, la valeur de hachage calculée de l'adresse de mémoire avec une valeur de hachage associée à une balise stockée dans une ligne d'antémémoire qui correspond à l'identificateur de ligne d'antémémoire auquel il a été accédé depuis la mémoire intermédiaire (140) à l'aide de la valeur de hachage calculée ;

    - en réponse à une correspondance dans la comparaison en raison du conflit, autoriser l'accès à la ligne d'antémémoire identifiée par l'identificateur de ligne d'antémémoire auquel il a été accédé ; et

    - mettre à jour la ligne d'antémémoire identifiée par l'identificateur de ligne d'antémémoire auquel il a été accédé en stockant la balise de la nouvelle adresse de mémoire et associer la valeur de hachage correspondante à la balise stockée.


     
    48. Procédé selon la revendication 47, caractérisé par les étapes consistant, en réponse à une absence de correspondance dans la comparaison, à mettre à jour l'identificateur de ligne d'antémémoire dans la mémoire intermédiaire (140) à l'aide de l'identificateur de ligne d'antémémoire attribué le plus ancien, et à autoriser l'accès à la ligne d'antémémoire identifiée par l'identificateur de ligne d'antémémoire attribué le plus ancien.
     
    49. Procédé selon l'une quelconque des revendications 45 à 48, caractérisé en ce que les identificateurs de ligne d'antémémoire dans la première plage limitée sont attribués cycliquement à la mémoire intermédiaire (140).
     
    50. Procédé selon la revendication 49, caractérisé par l'étape consistant à passer un identificateur de ligne d'antémémoire, dans l'attribution cyclique des identificateurs de ligne d'antémémoire, si l'identificateur de ligne d'antémémoire est détecté comme actif.
     
    51. Procédé selon la revendication 47, caractérisé par l'étape consistant, en réponse à une absence de correspondance dans la comparaison, à mettre à jour l'identificateur de ligne d'antémémoire auquel il a été accédé dans la mémoire intermédiaire à l'aide de l'identificateur de ligne d'antémémoire utilisé le plus récemment, et à autoriser l'accès à la ligne d'antémémoire identifiée par cet identificateur de ligne d'antémémoire.
     
    52. Procédé selon l'une quelconque des revendications 45 à 47, caractérisé par l'étape consistant à attribuer à la mémoire intermédiaire l'identificateur de ligne d'antémémoire utilisé le moins récemment pour permettre l'accès à la ligne d'antémémoire correspondante.
     
    53. Procédé selon la revendication 51 ou 52, caractérisé par l'étape consistant à agencer des identificateurs de ligne d'antémémoire dans la première plage limitée sous la forme d'une liste triée (150) en fonction de leur utilisation, les identificateurs de ligne d'antémémoire utilisés le plus récemment se trouvant à la fin de la liste, dans lequel l'identificateur de ligne d'antémémoire en tête de la liste est utilisé comme identificateur de ligne d'antémémoire utilisé le moins récemment.
     
    54. Procédé selon la revendication 30, caractérisé en ce que ladite première mémoire est une mémoire de contextes ou une antémémoire.
     
    55. Procédé selon la revendication 30, caractérisé en ce que ladite première mémoire est une mémoire de contextes et lesdits identificateurs sont des identificateurs de contextes.
     
    56. Procédé selon la revendication 30, caractérisé en ce que ladite première mémoire est une antémémoire et lesdits identificateurs sont des identificateurs de ligne d'antémémoire.
     




    Drawing







































    REFERENCES CITED IN THE DESCRIPTION



    This list of references cited by the applicant is for the reader's convenience only. It does not form part of the European patent document. Even though great care has been taken in compiling the references, errors or omissions cannot be excluded and the EPO disclaims all liability in this regard.

    Patent documents cited in the description




    Non-patent literature cited in the description