(19)
(11)EP 3 332 519 B1

(12)EUROPEAN PATENT SPECIFICATION

(45)Mention of the grant of the patent:
26.06.2019 Bulletin 2019/26

(21)Application number: 16729275.4

(22)Date of filing:  16.06.2016
(51)International Patent Classification (IPC): 
H04L 12/801(2013.01)
H04L 12/825(2013.01)
H04L 12/823(2013.01)
H04L 12/851(2013.01)
H04L 12/835(2013.01)
(86)International application number:
PCT/EP2016/063867
(87)International publication number:
WO 2017/021046 (09.02.2017 Gazette  2017/06)

(54)

DATA PACKET NETWORK

DATENPAKETNETZWERK

RÉSEAU DE PAQUETS DE DONNÉES


(84)Designated Contracting States:
AL AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC MK MT NL NO PL PT RO RS SE SI SK SM TR

(30)Priority: 06.08.2015 EP 15180017

(43)Date of publication of application:
13.06.2018 Bulletin 2018/24

(73)Proprietor: British Telecommunications public limited company
London EC1A 7AJ (GB)

(72)Inventors:
  • BRISCOE, Robert
    London EC1A 7AJ (GB)
  • EARDLEY, Philip
    London EC1A 7AJ (GB)

(74)Representative: British Telecommunications public limited company Intellectual Property Department 
Ground Floor, Faraday Building 1 Knightrider Street
London EC4V 5BT
London EC4V 5BT (GB)


(56)References cited: : 
US-A1- 2003 007 454
US-A1- 2006 013 241
  
      
    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

    Field of the Invention



    [0001] The present invention relates to a data packet network and to a method of controlling packets in a data packet network.

    Background



    [0002] A majority of networks in use today use discrete data packets which are transferred between a sender and receiver node via one or more intermediate nodes. A common problem in these data packet networks is that the sender node has little or no information on the available capacity in the data packet network, and thus cannot immediately determine the appropriate transmission rate at which it may send data packets. The appropriate transmission rate would be the maximum rate at which data packets can be sent without causing congestion in the network, which would otherwise cause some of the data packets to be dropped and can also cause data packets on other data flows (e.g. between other pairs of nodes which share one or more intermediate nodes along their respective transmission paths) to be dropped.

    [0003] To address this problem, nodes in data packet networks use either a closed or open-loop congestion control algorithm. Closed loop algorithms rely on some congestion feedback being supplied to the sender node, allowing it to determine or estimate the appropriate rate at which to send future data packets. However, this congestion feedback can become useless in a very short amount of time, as other pairs of nodes in the network (sharing one or more intermediate nodes along their transmission paths) may start or stop data flows at any time. Accordingly, the congestion feedback can quickly become outdated and the closed loop algorithms do not accurately predict the appropriate rate to send data packets. This shortcoming becomes ever more serious as capacities of links in data packet networks increase, meaning that large increases or decreases in capacity and congestion can occur.

    [0004] Open-loop congestion control algorithms are commonly used at the start of a new data flow when there is little or no congestion information from the network. One of the most common congestion control algorithms is the Transmission Control Protocol, TCP, 'Slow-Start' algorithm for Internet Protocol, IP, networks, which has an initial exponential growth phase followed by a congestion avoidance phase. When a new TCP Slow-Start flow begins, the sender's congestion window (a value representing an estimate of the congestion on the network) is set to an initial value and a first set of packets is sent to the receiver node. The receiver node sends back an acknowledgement to the sender node for each data packet it receives. During the initial exponential growth phase, the sender node increases its congestion window by one packet for every acknowledgment packet received. The congestion window, and thus the transmission rate, is therefore doubled every round trip time. Once the congestion window reaches the sender node's Slow-Start Threshold ('ssthresh'), then the exponential growth phase ends and it starts the congestion avoidance phase in which the congestion window is only increased by one packet for every round-trip it receives an acknowledgement, regardless of how many acknowledgment packets are received. If at any point an acknowledgement packet (or its absence) indicates that a loss has occurred, which is likely due to congestion on the network, then the sender node responds by halving the congestion window in an attempt to reduce the amount of congestion caused by that particular data flow. However, the sender node receives this feedback (i.e. the acknowledgment packet indicating that a loss had occurred) one round trip time after its transmission rate exceeded the available capacity. By the time it receives this feedback it will already be sending data twice as fast as the available capacity. This is known as 'overshoot'.

    [0005] The exponential growth phase can cause issues with non-TCP traffic. Consider the case of a low-rate (e.g. 64kB/s) constant bit-rate voice flow in progress over an otherwise empty 1 GB/s link. Further imagine a large TCP flow starts on the same link with an initial congestion window of ten 1500B packets and a round trip time of 200ms. The flow keeps doubling its congestion window every round trip until, after nearly eleven round trips, its window is 16,666 packets per round (1Gb/s). In the next round it will double to 2Gb/s before it gets the first feedback detecting drops that imply it exceeded the available capacity in the network a round trip earlier. About 50% of the packets in this next round (16,666 packets) will be dropped.

    [0006] In this example, the TCP Slow-Start algorithm has taken eleven round-trip times (over two seconds) to find its correct operating rate. Furthermore, when TCP drops such a large number of packets, it can take a long time to recover, sometimes leading to a black-out of many more seconds. The voice flow is also likely to black-out for at least 200ms and often much longer, due to at least 50% of the voice packets being dropped over this period.

    [0007] There are thus two main issues with the overshoot problem. Firstly, it takes a long time for data flows to stabilise at an appropriate rate for the available network capacity and, secondly, a very large amount of damage occurs to any data flow having a transmission path sharing the now congested part of the network.

    [0008] Further concepts of data packet networks will now be described.

    [0009] A node typically has a receiver for receiving data packets, a transmitter for transmitting data packets, and a buffer for storing data packets. When the node receives a data packet at the receiver, it is temporarily stored in the buffer. If there are no other packets currently stored in the buffer (i.e. the new packet is not in a 'queue') then the packet is immediately forwarded to the transmitter. If there are other packets in the buffer such that the new packet is in a queue, then it must wait its turn before being forwarded to the transmitter. A few concepts regarding the management and exploitation of node buffers will now be described.

    [0010] A node implementing a very basic management technique for its buffer would simply store any arriving packet in its buffer until it reaches capacity. At this point, any data packet which is larger than the remaining capacity of the buffer will be discarded. This is known as drop-tail. However, this results in larger packets being dropped more often that smaller packets, which may be still be added to the end of the buffer queue. An improvement on this technique was a process known as Active Queue Management (AQM), in which data packets are dropped when it is detected that the queue of packets in the buffer is starting to grow above a threshold rate, but before the buffer is full. This gives the buffer sufficient capacity to absorb bursts of packets, even during long-running data flows.

    [0011] Some nodes may treat each data packet in its buffer the same, such that data packets are transmitted in the same sequence in which they were received (known as "First In First Out"). However, node buffer management techniques introduced the concept of marking data packets with different classes of service. This technique can be used by defining certain classes as higher than others, and a network node can then implement a forwarding function that prevents or mitigates the loss or delay of packets in a higher class at the expense of a packet in a lower class. Examples of techniques that manage packet buffers using differing classes of service include:
    • (Non-strict) Prioritisation: In this technique, higher class packets will be forwarded by a network node before a lower class packet, even if the lower class packet arrived at the node earlier. This is often implemented by assigning a lower weight to a lower class, and serving each class in proportion to its weight.
    • Strict Prioritisation: Similar to the non-strict prioritisation, although a lower class packet will never be forwarded whilst a higher class packet is present in the buffer.
    • Traffic Policer: A network node may enforce a traffic profile specifying, for example, limits on the average rate and the maximum size of bursts. Any data flow that does not meet the profile is marked accordingly and may be discarded if congestion reaches a certain level.
    • Preferential Discard: If a buffer is filled with a queue of data packets, then any lower class packets will be preferentially discarded before higher class packets.
    • Selective Packet Discard: A proportion of the buffer is reserved for higher class data packets. The lower class packets may only occupy a smaller proportion of the buffer (relative to the buffer of that node without selective packet discard), and packets will be discarded if that smaller buffer is full.
    • AQM: AQM, as mentioned above, drops packets when it is detected that the queue of packets in the buffer is starting to grow above a threshold rate. This can be modified such that the packets dropped by AQM are those of a lower class of service.


    [0012] The approaches of Strict Prioritisation and Preferential Discard were both proposed to ensure lower class packets cannot cause harm to higher class packets. However, there are still problems with these techniques. In Strict Prioritisation, some network nodes may have one or more higher priority packets in the buffer for long periods (many seconds or even minutes), particularly during peak hours. This causes any lower class data packets to remain in the buffer for a long period of time. During this period, the sending/receiving nodes would probably time out and the data packet would be retransmitted in a higher class (on the assumption that the lower class packet was discarded). When the busy period in the higher priority buffer ends, the buffer of lower class data packets is finally transmitted. This merely wastes capacity as the data has already been received from the retransmitted higher-priority packet.

    [0013] Network nodes can exploit the lower class data packets to determine the available capacity in the network (known as 'probing'). In Preferential Discard, a burst of 'discard eligible' probing data packets may fill up a buffer, and only then is Preferential Discard triggered. During probing the discard eligible packets will cause a queue up to the discard threshold even if newly arriving probing traffic is discarded. Thus, probing will not be non-intrusive because higher class traffic from established flows will experience increased delay.

    [0014] US Patent Application Publication Number 2003/007454 A1 discusses a packet-based service differentiation technique for packet-based networks based on inferred connection characteristics.

    [0015] It is therefore desirable to alleviate some or all of the above problems.

    Summary of the Invention



    [0016] According to a first aspect of the invention, there is provided a method of controlling packets in a data packet network as claimed in Claim 1.

    [0017] According to a second aspect of the invention, there is provided a method of controlling a network node as claimed in Claim 7.

    [0018] The present invention provides a new class of service for data packets in which the data packet may not be queued if there are already data packets present in a buffer of an intermediate node between a sending and receiving node. If another data packet is present in the buffer, then the unqueuable packet may be discarded by the intermediate node. These packets may be sent at the beginning of a data transfer between a sending and receiving node (e.g. at an early stage of the exponential growth phase of the TCP Slow-Start algorithm), and these unqueuable packets may then be dropped at the intermediate node which represents a bottleneck in the transmission path between the sending and receiving nodes. Accordingly, any acknowledgment packet sent back from the receiving node to the sending node in response to the unqueuable packets has the effect of limiting the transmission rate of future packets to the bottleneck rate of the network. The present invention therefore provides a method of establishing the appropriate transmission rate much earlier in the data transfer than TCP Slow-Start and, in doing so, drops fewer data packets.

    [0019] The method may further comprise the step of the source node sending an initial set of packets to the receiver node over the data packet network via the intermediate node, wherein the initial set of packets are of a class of service allowing them to be queued at the intermediate node. The rate the source node sends the first set of packets may be higher than the rate the source node sends the initial set of packets. In this manner, the rate at which the acknowledgment packets are received by the source node is closer to the bottleneck rate.

    [0020] The first set of packets may contain dummy data. These first set of packets may therefore be probing packets which do not contain requested data, and thus do not have to be retransmitted if dropped. Alternatively, the first set of packets may contain requested data, and the acknowledgement may indicate that a packet of the first set of packets was prevented from being forwarded to the receiver node; and the second set of packets may include a retransmission of said prevented packet.

    [0021] The source node may be a node containing the requested data (and thus the original source of a transmission) or an intermediate node between the original source and the receiving node. Any two nodes in a data packet network may use the method of the present invention in order to establish the bottleneck rate of a transmission path, and may do so at any time. In one embodiment, as detailed below, the method of the present invention is performed at the start of a new data flow. Alternatively, the method of the present invention may be performed before a new data starts, and the calculated bottleneck rate may then be used to configure the transmission rate of the new data flow. Thus, the method may further comprise the steps of: the source node receiving a second acknowledgement of a second received packet of the first set of packets from the receiver node; the source node determining a transmission rate between the source node and receiver node based on the rate the first and second acknowledgements are received at the source node; the source node transmitting a second set of data packets to the receiver node based on the determined transmission rate.

    [0022] A network node and a computer program configured to carry out the methods of the first and second aspects of the invention are also provided. A network comprising said network node is also provided.

    [0023] According to a third aspect of the invention, there is provided a data packet for transmission in a data packet network, wherein the data packet is identifiable by a node in the data packet network as being of a class of service such that it should not be forwarded if a packet queue exists at said node. The data packet may further comprise an identifier indicating that the data packet is unqueuable.

    Brief Description of the Figures



    [0024] In order that the present invention may be better understood, embodiments thereof will now be described, by way of example only, with reference to the accompanying drawings in which:

    Figure 1 is a schematic diagram of a communications network of an embodiment of the present invention;

    Figure 2a is a schematic diagram illustrating a router of the network of Figure 1;

    Figure 2b illustrates a data packet of an embodiment of the present invention;

    Figure 3 is a schematic diagram illustrating the data packet of Figure 2b being processed by a router of the communications network of Figure 1 in a first scenario;

    Figure 4 is a schematic diagram illustrating the data packet of Figure 2b being processed by a router of the communications network of Figure 1 in a second scenario;

    Figure 5a is a flow diagram illustrating a method of processing the data packet of Figure 2b;

    Figure 5b is a flow diagram illustrating an alternative method of processing the data packet of Figure 2b;

    Figure 6 is a timing diagram representing the TCP Slow-Start algorithm of the prior art;

    Figure 7 is a timing diagram illustrating an embodiment of a method of the present invention;

    Figure 8 is a schematic diagram illustrating the self-clocking characteristic of the present invention;

    Figure 9a is a timing diagram representing the TCP Slow-Start algorithm of the prior art for a large data flow;

    Figure 9b is a timing diagram representing the embodiment of the method of Figure 7 for a large data flow;

    Figure 10 is a schematic diagram of a communications network of a second embodiment of the present invention, illustrating a middlebox; and

    Figure 11 is a timing diagram representing a second embodiment of a method of the present invention.


    Detailed Description of Embodiments



    [0025] A first embodiment of a communications network 10 of the present invention will now be described with reference to Figures 1 to 2b. The communications network 10 is a data packet network having a client 11, a server 18, a plurality of customer edge routers 13, 17, a plurality of provider edge routers 13, 16, and a plurality of core routers 15. The client 11 sends data packets to the server 18 via path 12, which traverses a plurality of customer edge, provider edge and core routers. The skilled person will understand that other clients and servers may be connected to the customer edge routers, and other customer edge routers may be connected to the provider edge routers.

    [0026] When the client 11 sends a data packet along path 12, it is initially forwarded to a first customer edge router 13, which forwards it on to the first provider edge router 14. The first provider edge router 14 forwards the data packet to a core router 15, which in turn forwards it on to a second provider edge router 16 (which may be via one or more other core routers). The second provider edge router 16 forwards the data packet to a second customer edge router 17, which forwards it on to the server 18.

    [0027] A core router 15 is shown in more detail in Figure 2a (and the skilled person will understand that any other router from Figure 1 includes a similar construction). The core router 15 includes a receiver 15a adapted to receive data packets, a processor 15b, a first memory 15c including a buffer 20 for storing data packets awaiting transmission, and a transmitter 15d for sending a data packet. All modules of the router 15 are connected via a bus 15e.

    [0028] Figure 2b illustrates a data packet 100 of the present invention. The data packet 100 includes a header portion 110 and a data payload portion 120. The header portion 110 is modified to include an identifier 115 that the data packet 100 is of an unqueuable class of service. The processor 15b of the router 15 (and, for completeness, any other node in the communications network 10) is adapted to decode the header portion 110 of the data packet and determine that it is unqueuable (in contrast to other classes of service, such as Best-Efforts (BE), which may be queued). A router 15 of the communications network 10 may therefore only store this UQ packet if there are no other data packets currently being stored in the buffer 20.

    [0029] The skilled person will understand that the identifier may be stored in the 6-bit Differentiated Services field (DSfield) of an IPv4 or IPv6 packet, the 3-bit 802.1p Class of Service (CoS) field of an Ethernet frame or the 3-bit Traffic Class field of an MPLS frame. The skilled person will also understand that other identifiers or codepoints could be used, so long as the relevant nodes in the network understand that this identifier/codepoint indicates that the data packet is unqueuable. This will now be explained with reference to two scenarios illustrated in Figures 3 and 4.

    [0030] A schematic diagram illustrating an overview of the processing of data packets by core router 15 in accordance with the present invention is shown in Figure 3. Data packets arrive at the core router 15 via the receiver 15a. In the diagram, data packets are either of a queuable class (e.g. a conventional Best-Efforts (BE) data packet), or an unqueuable (UQ) class according to the present invention. In the scenario depicted in Figure 3, a first packet 23 arrives at the receiver 15d, and a management function 22 (of processor 15b, which generally classifies, schedules and enqueues arriving data packets) determines that it is of the unqueuable class, but also determines that there are no data packets present in the buffer 20. The management function 22 therefore stores the first packet 23 in the buffer 20 whilst the dequeuing function 21 (also implemented by processor 15b) forwards it to the transmitter 15d.

    [0031] Whilst the first packet 23 is being forwarded to the transmitter 15d, a second packet 24 arrives at the receiver 15a. The management function 22 determines that the second packet 24 is a queuable BE packet. In this scenario, the first packet 23 has not yet been fully transmitted and is thus still present in the buffer 20. The second packet 24 is thus stored in the buffer 20 behind the first packet 23. A third packet 25 then arrives at the receiver 15a whilst the first and second packets 23, 24 are still present in the buffer 20. The management function 22 determines that the third packet 25 is a UQ packet and that there are already data packets in the buffer 20. In this case, the management function 20 discards the data packet (i.e. it is prevented from being transmitted to the server 18). Lastly, a fourth packet 26 arrives, and is again determined to be a queuable BE packet and is therefore stored in the buffer 20.

    [0032] A second scenario is illustrated in Figure 4, in which the first packet 27 to arrive at the receiver 15a whilst the buffer 20 is empty is a queuable BE packet. The management function 22 stores this packet in the buffer 20 whilst it is being forwarded to the transmitter 15d by the dequeuing function 21. Whilst the first packet 27 is being forwarded, a second packet 28 of the UQ class arrives. The management function 22 determines that it is of the UQ class and that the buffer is non-empty. The second packet 28 is therefore discarded. As further queuable BE packets (e.g. packet 29) arrive, the management function may store them in the buffer 20 even if the first packet 27 is still being forwarded.

    [0033] In the above two scenarios, the packets are deemed to have left the buffer at the time the transmitter completes its transmission of the last byte of the packet. Once this last byte has completed its transmission, then the buffer may store an unqueuable packet.

    [0034] A flow diagram representing a first embodiment of the management function 22 of the processor 15b is shown in Figure 5a. In step S1 of this diagram, a new data packet is examined to determine whether it is of the UQ class. This may be achieved by the processor 15b decoding the header portion 110 of the data packet and determining whether the identifier/codepoint matches a known identifier/codepoint for the UQ class. If the processor 15b determines that the new data packet is of a queuable class, the processor 15b passes the new data packet to the enqueuing function and it is stored in buffer 20 (step S2). However, if the processor 15b determines that the new data packet is unqueuable, then the processor 15b determines whether the buffer 20 is empty or not. If it is empty, then the processor 15b again passes the new data packet to the enqueuing function and it is stored in buffer 20 (step S3). Alternatively, if the processor 15b determines that that buffer is not empty, then the processor 15b discards the packet (step S4).

    [0035] A flow diagram illustrating a second embodiment of the management function 22 of the processor 15b is shown in Figure 5b. In this embodiment, the steps of determining whether the buffer is empty and determining whether the packet is unqueuable are reversed.

    [0036] The unqueuable class of service can be exploited by a sender/receiver node 11, 18 pair in order to determine an appropriate transfer rate to use in the communications network 10 (i.e. the maximum rate at which data can be transmitted without causing any packets to be dropped or causing packets on data flow sharing part of the same transmission path to be dropped). Before an embodiment of this algorithm is described, an overview of the conventional TCP Slow-Start process and its corresponding timing diagram will be presented with reference to Figure 6.

    [0037] Figure 6 is a timing diagram in which two time axes extend downwardly from a client (e.g. client 11) and a server (e.g. server 18). Various data packets are represented by arrows extending between the two time axes, which illustrate a data packet being sent or received by the client or server (such that the root of an arrow represents the time the client/server sends a packet, and the head of the arrow represents the time the client/server receives the packet). The data packets will typically traverse several customer edge routers, provider edge routers and core routers (as illustrated in Figure 1), but only the two end-systems are illustrated for simplicity. In the TCP Slow-Start process, the client sends an initial request to the server for data. The server responds by buffering a stream of data packets to send to the client and sets its initial congestion window to the current standard TCP size of three packets. Accordingly, the server sends three packets of data (represented by thick unbroken arrows) from the buffer towards the client, which are all marked as BE class of service.

    [0038] In this example, these three packets do not experience any congestion and are all received by the client in a timely manner. The client therefore sends an acknowledgment packet (represented by thin unbroken arrows) for each of the three packets of data to the server. The server receives these acknowledgements and, in response, increases the congestion window (by one packet for each acknowledgement received). The server therefore sends six data packets in the next transmission. In Figure 6, there are four round trips of data packets being sent and acknowledgments received before the server has completed the transfer of all the data packets from its buffer. The algorithm therefore remains in the exponential growth phase until it completes the transfer.

    [0039] The skilled person would understand that if the data stream were much larger, then the TCP Slow-Start algorithm would increase its congestion window by one packet for each acknowledgement received until it reaches its slow start threshold. Once this threshold is reached, then the congestion window is increased by one packet if it receives an acknowledgment within one round-trip time (i.e. before a time-out occurs), regardless of how many acknowledgments are received in that time. The algorithm therefore moves from an exponential growth phase to a linear congestion avoidance phase. The skilled person would also understand that if a time-out occurs without receiving any acknowledgements, or an acknowledgement is received indicating that packets have been dropped, then the congestion window is halved.

    [0040] An embodiment of a method of the present invention will now be described with reference to Figure 7. Figure 7 is also a timing diagram in which two time axes extend downwardly from the client 11 and the server 18, in which various data packets are represented by arrows extending between the two time axes illustrating a data packet being sent or received by the client 11 or server 18 (such that the root of an arrow represents the time the sender/receiver node sends a packet, and the head of the arrow represents the time the sender/receiver node receives the packet). Again, the data packets traverse several customer edge routers 13, 17, provider edge routers 14, 16 and core routers 15 (as illustrated in Figure 1), but only the two end-systems are shown for simplicity.

    [0041] The initial steps of the method of the present invention are very similar to the Slow-Start method outlined above. The client 11 sends an initial request 52 to the server 18 for data. The server 18 responds by buffering a stream of data packets to send to the client 11 and sets its initial congestion window to the current standard TCP size of three packets. Accordingly, the server 18 sends three packets of data 54 from the buffer towards the client 11, which are all marked as BE class of service (represented by thick, unbroken arrows).

    [0042] At this point, the method of the present invention differs from the conventional Slow-Start algorithm. Following the initial three BE packets of data, the server 18 continues to send further data packets 55 from the buffer towards the client 11. Each of these further data packets are marked as UQ (e.g. the header portions contain an identifier/codepoint which all nodes in the communications network 10 recognise as being of the unqueuable class), and, in this embodiment, are sent at a higher transmission rate than the first three BE packets. These UQ data packets are represented by dashed arrows in Figure 7.

    [0043] The initial BE data packets and the following burst of UQ data packets leave the server 18 at the maximum rate of its transmitter. In this example, this is over a 1GB/s connection between the network interface on the server 18 and the second customer edge router 17 (e.g. a 1Gb/s Ethernet link). Once these BE and UQ packets arrive at the second customer edge router 17, they are forwarded to the second provider edge router 16. In this example, this is over a 500Mb/s access link. Thus, when the first UQ packet arrives at the second customer edge router 17, the second customer edge router's 17 relatively slower output rate (i.e. the slower transmission rate of forwarding packets to the second provider edge router 16 relative to the transmission rate of receiving packets from the server 18) represents a bottleneck in the communications network 10. The second customer edge router's 17 buffer 20 will therefore have to queue the received data packets according to the management function 22 described earlier.

    [0044] Accordingly, the first three BE packets arrive at the second customer edge router 17. The header portions of all these BE packets are decoded and the management function 22 determines that they are all queuable BE packets. In this example, there are initially no other data packets in buffer 20. Accordingly, all three BE packets are stored in the buffer 20 and the first of these BE packets is forwarded to the transmitter.

    [0045] As noted above, a stream of UQ packets are sent from the server 18 to the second customer edge router 17 after these initial three BE packets. The first of these UQ packets arrive at the second customer edge router 17 and the header portion is decoded. The management function 22 determines that it is an UQ packet. It also determines that the buffer 20 is not empty (as the three BE packets have not all been transmitted when the first UQ packet arrives) and thus discards the first UQ packet. The discarded UQ packet is represented by a line having a diamond head (rather than an arrow head) terminating in the area between the server 18 and client 11 in Figure 7.

    [0046] The second of the UQ packets arrives at the second customer edge router 17 and the header portion is decoded. The management function 22 again determines that it is an UQ packet and again also determines that the buffer 20 is not empty. The second UQ packet is therefore discarded.

    [0047] Eventually, all three BE packets are successfully transmitted to the second provider edge router 16 and the buffer 20 of the second customer edge router 17 is empty. The third UQ packet then arrives at the second customer edge router 17 and the header portion is decoded. Again, the management function 22 determines that it is an UQ packet but now determines that the buffer 20 is empty. The third UQ packet is therefore stored in the buffer 20 and forwarded to the transmitter 57 for onward transmission to the provider edge router 16 (and ultimately the client 11). This is illustrated in Figure 7 as the third dashed line extending from the server's 18 time axis (representing the third UQ packet) to the client 11.

    [0048] Whilst the third UQ packet is being transmitted, a fourth UQ packet arrives and the header portion is decoded. The management function 22 determines that it is an UQ packet and that the buffer is not empty (as the third UQ packet is stored in the buffer 20 whilst it is being transmitted). The fourth UQ packet is therefore discarded.

    [0049] Meanwhile, as shown in Figure 7, the initial three BE packets arrive at the client 11. In response, the client 11 sends three BE acknowledgment messages 58 back to the server 18 indicating that the BE packets were successfully received. Note that, for the purposes of this description, the terms BE acknowledgment messages and UQ acknowledgment messages are used to differentiate between acknowledgement messages sent in response to a BE or UQ message respectively, but do not necessarily imply any difference between the messages themselves.

    [0050] Whilst these BE acknowledgment messages traverse the communications network 10 to the server 18, the server 18 continues sending UQ packets to the client 11. As noted above and as shown in Figure 7, some of these UQ packets successfully traverse the communications network 10 and arrive at the client 11, whilst some are dropped by an intermediate node (e.g. the second customer edge router 17, which drops an UQ packet as the previous UQ packet is present in the buffer 20 whilst it is being transmitted). Whenever an UQ packet successfully arrives at the client 11, the client 11 sends out an UQ acknowledgment message 59.

    [0051] As shown in Figure 7, the rate at which the client 11 sends out the BE acknowledgment messages (i.e. in response to the initial BE packets) is greater than the rate at which the client 11 sends out UQ acknowledgement message in response to the UQ packets. This is due to some UQ packets being dropped whenever it experiences a queue at an intermediate node between the server 18 and the client 11 coupled with the small time delay between each UQ packet being sent by the server. This has important consequences on how the server 18 determines the appropriate transmission rate for the communications network 10, as will now be described.

    [0052] When the first BE acknowledgment message arrives at the server 18, the server 18 stops sending UQ data packets to the client 11. The server 18 is configured, on receipt of this BE acknowledgment message, to end its start-up phase and enter a congestion-avoidance phase. Like the conventional TCP Slow-Start algorithm, the algorithm of this embodiment of the present invention is self-clocking', such that a new data packet is transmitted from the server 18 towards the client 11 in response to each acknowledgement it receives. In this embodiment, following receipt of the first BE acknowledgment packet from the client 11, the server 18 starts sending a second batch of BE packets 60 to the client 11. The first three BE packets of this second batch is sent at a transmission rate corresponding to the rate at which it receives the first three BE acknowledgment messages. However, it will be seen from Figure 7 that the server 18 then starts receiving the UQ acknowledgment messages (sent by the client 11 in response to the successfully received UQ packets) 61. Each of these UQ acknowledgment messages has the effect of modifying the transmission rate of the next BE packets in the second batch of BE packets. In this example, as noted above, the rate of UQ acknowledgment packets is lower than that of the initial BE acknowledgment messages, and the self-clocking nature of the algorithm therefore reduces the transmission rate of the next BE packets to the bottleneck rate This new rate is slightly less than the bottleneck rate due to UQ packets being dropped by an intermediate node whenever there is a queue present and due to the small time delay between successive UQ packets being sent by the server. However, this difference between the two rates can be reduced to negligible amounts if this time delay is minimised (for example, by using small UQ packets which require minimal processing).

    [0053] This self-clocking nature can be explained using the schematic diagram shown in Figure 8. This diagram illustrates a sender and receiver node on high bandwidth networks connected by a relatively low bandwidth link (in the diagram, the vertical dimension represents bandwidth and the horizontal dimension represents time). The sender node sends a burst of packets (each shown in cross-hatch) back-to-back towards the sender. As the packets traverse the low-bandwidth link, the packet must spread out in time (as the number of bits in each packet remains the same). The time Pb represents the minimum packet spacing on the slowest link in the path (i.e. the bottleneck). As the packets leave the bottleneck into the receiver's relatively high-bandwidth network, the inter-packet interval stays the same (i.e. Pr = Pb). The receiver node then sends an acknowledgement packet to the sender node at the same rate as the packets are received (assuming the processing time is negligible), and so the spacing between these acknowledgement packets is the same as the inter-packet interval (i.e. Ar = Pr = Pb). The acknowledgement packet is typically smaller than the original packets, so the acknowledgment packet should traverse the low-bandwidth link without any change in interval (i.e. Ab = Ar). Therefore, if any subsequent packets from the sender are sent only in response to receiving an acknowledgement packet, the spacing between the sender's subsequent packets will exactly match the bottleneck rate on the slowest link in the network.

    [0054] Accordingly, as shown in Figure 7, the server 18 continues to send the second batch of BE packets at this bottleneck rate. This happens until it receives an acknowledgement from the client 11 from the first packet of the second batch of BE packets. Thus, the last few packets sent from the server 18 in Figure 7 are sent according to the rate at which these acknowledgment messages are received at the server 18.

    [0055] The skilled person will understand that the first UQ acknowledgment message to arrive at the server 18 will indicate that some data has not arrived at the client 11 (due to some UQ packets being dropped). The server 18 therefore retransmits this data by including it in the second batch of BE packets. This behaviour therefore repairs all losses of data in the UQ packets. Once all this lost data has been retransmitted, the server 18 will send out any remaining new data until its buffered data has all been sent. The server will then terminate the connection (not shown).

    [0056] The method of the present invention therefore uses the new UQ packets to probe the network and more rapidly establish the appropriate transmission rate of the end-to-end path through the network. This is clear when the algorithm of the present invention is compared to TCP Slow-Start for a larger data stream, as shown in Figures 9a and 9b.

    [0057] Figure 9a illustrates a TCP Slow-Start algorithm for a larger data stream. The algorithm starts in the same manner as described for Figure 6, such that the client 11 sends a request to a server 18 and the transmission rate enters an exponential growth phase. Figure 9a continues on from Figure 6 as there are more data packets to transfer between the two end-systems. Each acknowledgment packet received by the server 18 causes its congestion window to increase by two packets, thus increasing the transmission rate between the server 18 and client 11. In the fourth transmission of packets from the server 18, the transmission rate is greater than the bottleneck rate in the network (e.g. at the second provider edge router), and the bottleneck router's buffer is full. Accordingly, the bottleneck router drops the packet (represented by the broken line having a diamond head (71)). Subsequently, about half of all the sent data packets will be discarded as the transmission rate reaches twice the bottleneck rate. This will continue until the acknowledgment of the first packet after the first dropped packet reaches the server 18. At this point, the server 18 determines that a loss has occurred and responds by halving the congestion window. It will then retransmit the data from the lost data packets before resuming sending new data until the transfer is complete.

    [0058] It will be seen from Figure 9a that this behaviour results in a large amount of data loss in the BE class when the transfer overshoots the bottleneck rate at the end of the exponential growth phase of the TCP Slow-Start algorithm. If other data flows share the same transmission path in this now congested part of the network, this overshoot will cause them to suffer the same proportion of loss as the illustrated flow.

    [0059] Figure 9b illustrates the same data transfer but using the method of the present invention. By comparing this data flow to the TCP Slow-Start algorithm of Figure 9a, it can be seen that the method of the present invention suffers loss of data packets at the start of the data transfer. However, after the first round of data packets, the server 18 establishes the bottleneck rate of the network and (due to the self-clocking nature of the algorithm), and sends out future packets at this bottleneck rate. The method of the present invention therefore establishes the bottleneck rate of the network much more quickly than the TCP Slow-Start algorithm and achieves this without significantly overshooting the bottleneck rate (which would otherwise cause a significant drop of packets for the data flow and for other data flows).

    [0060] A second embodiment of the present invention will now be described with reference to Figures 10 and 11. This embodiment is substantially the same as that of the first embodiment. In this embodiment, a middlebox 83 (which may be provided as part of a Wide Area Network (WAN) Accelerator), is provided and connected to the second customer edge router 17. This middlebox 83 allows the network to take advantage of the unqueuable class of service, even if the client 81 and server 85 have not yet been adapted to send packets in the manner described in the first embodiment of the invention. This will now be explained, with reference to Figure 11, which is also a timing diagram in which three time axes extend downwardly from the client 81, the middlebox 83 and the server 85. Again, various data packets are represented by arrows extending between the three time axes illustrating a data packet being sent or received by the client 81, middlebox 83 or server 85 (such that the root of an arrow represents the time the sender/receiver node sends a packet, and the head of the arrow represents the time the sender/receiver node receives the packet). Again, the data packets traverse several customer edge routers 13, 17, provider edge routers 14, 16 and core routers 15 (as illustrated in Figure 1), but only the client, middlebox and server are shown for simplicity.

    [0061] The client 81 sends a request packet 82 to the server 85 for a data transfer. In this embodiment, the middlebox 83 intercepts this request packet 82 (for example, by monitoring all data packets passing through the second customer edge router 17 and determining if any are request packets), and opens a connection back to the client 81. The middlebox 83 cannot yet send the data the client 81 has requested from the server, as it does not store it. The middlebox 83 therefore forwards the request onwards (84) to the server 85. The server 85 then starts a traditional TCP data transfer to the middlebox 83.

    [0062] In this embodiment, the server 85 does not need to be modified in any way. The data transfer between the server 85 and the middlebox 83 can therefore proceed according to the tradional TCP Slow-Start algorithm, which is illustrated in Figure 11 (reference 86). In this embodiment, the server 85 is in close proximity to the middlebox 83. The data transfer therefore accelerates up to full speed in much less time compared to a data transfer over a wide area network using the TCP Slow-Start algorithm (as depicted in Figure 6).

    [0063] However, as can be seen in Figure 11, once the middlebox 83 receives the stream of data packets from the server 85, it may initiate an unqueuable class of service data transfer as described in the first embodiment above. That is, the middlebox 83 may reclassify any data packet as an unqueuable packet (for example, by giving the packet the unqueuable class of service marking instead of the marking applied to the packet by the server 85), and send three data packets followed by a stream of UQ packets as described above.

    [0064] The advantages of the second embodiment are that the traditional TCP Slow-Start exchange between the server 85 and the middlebox 83 may accelerate to a very fast rate in a relatively short of amount of time (compared to a traditional TCP exchange over a WAN), and then the data transfer is translated into a unqueuable class of service data transfer to establish the bottleneck rate over the WAN. This may also be implemented without any modifications to the server 85, such that only the nodes from the customer edge router onwards (which are maintained by network operators) need to be able to distinguish an unqueuable packet from a packet of any other class of service.

    [0065] The skilled person would understand that the network could implement two middleboxes of the second embodiment, such that one is associated with the server and another is associated with the client, such that the advantages of the present invention could be realised in both the forward and reverse directions.

    [0066] In an enhancement to the above embodiments, any intermediate node between the client and server could dequeue packets at a slightly lower rate than its normal transmission rate. In this manner, a greater number of UQ packets would be dropped by the intermediate node, and consequently the rate of UQ acknowledgment packets being returned to the server decreases. As these UQ acknowledgment packets clock out further packets from the server, the new transmission rate may be artificially lowered below the rate that would be established by the method outlined above. This can therefore provide a safer transmission rate, which is just less than the bottleneck rate of the network.

    [0067] In another enhancement, a management entity could be connected to a node in the network (preferably the provider edge node), which may monitor data packets passing through the node to determine the proportion of packets which are being sent in the unqueuable class of service. This may be achieved by an interface with the header decoder function of the node, and appropriate logging mechanisms. Alternatively, deep packet inspection techniques could be used. The management entity allows the network operator to determine the usage of the unqueuable class of service by different clients and can thus help in deployment planning.

    [0068] In the above embodiment, the server 18 transmits the packets towards the core network routers via customer edge and provider edge routers. However, this is non-essential and the skilled person would understand that the invention may be implemented between any two network nodes communicating via at least one intermediate node. For example, the server may be connected directly to a core router 15 (which may be the case, for example, where the server is a high-bandwidth storage server for popular video streaming websites). In this case, the bottleneck node is likely to be at a more distant intermediate node (such as a provider edge router associated with the client), and the bottleneck rate can be established by this node dropping the UQ packets. Furthermore, the two network nodes implementing the invention could be in a peer-to-peer arrangement, rather than a server/client arrangement detailed above.

    [0069] In the above embodiments, the UQ packets are marked as unqueuable by a specific identifier in the header portion of the packet. However, the skilled person will understand that this method of ensuring a packet is unqueuable is non-essential. That is, the packets may be marked as unqueuable by using an identifier at any point in the packet, so long as any node in the network is able to decode this identifier. Furthermore, this marking does not necessarily need to be consistent, as a node may use deep packet inspection to determine the class of service without having to decode the identifier. The skilled person will understand that the UQ packet does not require any marking at all to be identifiable as of the unqueuable class of service. Instead, the unqueuable class of service may be inferred from a particular characteristic of the packet, such as its protocol, it being addressed to a particular range of addresses, etc. An intermediate node can then treat the packet as unqueuable based on this inference. Thus, the skilled person will understand that an 'unqueuable' data packet is one which network nodes generally understand should not be queued if a packet queue exists in the node

    [0070] In the above embodiments, the UQ packets include data that is part of the data to be transmitted from the server to the client, and any data lost as a result of a dropped UQ packet is resent by the server. However, the UQ packets may instead include dummy data (i.e. data which is not part of the data requested by the client, and typically just a random collection of bits). In this way, there are fewer packets of data which need to be retransmitted by the server.

    [0071] The skilled person will also understand that the use of the TCP protocol is non-essential, and the present invention may be applied in many other transport protocols implementing congestion control, such as the Stream Control Transmission Protocol or Real-time Transport Protocol over Datagram Congestion Control Protocol.

    [0072] The above embodiments describe the present invention operating between a server and client at the start of a new data flow. However, the skilled person will understand that the present invention may be used at any time in order to establish the bottleneck rate in the network. For example, the server may have established data flows with several clients, and one of the data flows may terminate. The server may then use the method of the present invention to quickly probe the network and establish the new bottleneck rate for its remaining data flow(s). Furthermore, the skilled person will understand that the second embodiment of the method of the invention, in which a middlebox is provided at an ingress and/or egress point of the core network, may be used to probe the network to determine a bottleneck capacity. Thereafter, when a new flow starts from a client associated with that middlebox, the transmission rate can be set based on this information.

    [0073] In the above embodiments, the intermediate node is configured to determine that its buffer is empty once the final byte of data for the last packet leaves the transmitter. However, the skilled person will understand that the transmitter may also implement a buffer to temporarily store packets as they are transmitted. The node may therefore disregard any packets stored in this temporary transmitter buffer when determining whether or not the node buffer is empty and thus whether a new UQ packet can be queued or not.

    [0074] The skilled person will understand that there are several ways in packets which are "unqueuable" may be realised. In the above embodiments, the unqueuable packets are received by the intermediate node and the intermediate node determines whether it is queuable or unqueuable, and if unqueuable, whether a packet queue exists at the node. If a packet queue exists at that time, the packet is discarded (e.g. it is deleted). However, it isn't essential for the packet to be discarded. In a more passive arrangement, the packet may just never be forwarded to its destination.

    [0075] The skilled person will understand the combinations of features which are possible within the scope of the invention, as claimed.


    Claims

    1. A method of controlling packets in a data packet network, the method comprising the steps of:

    a source node (11) sending a first set of packets to a receiver node (18) over the data packet network (10) via an intermediate node (15);

    the source node (11) receiving a first acknowledgement of a first received packet of the first set of packets from the receiver node (18); and

    the source node (11) sending a second set of packets to the receiver node (18) over the data packet network (10),

    the method characterised in that the source node (11) marks the first set of packets as being of an unqueuable class of service, wherein a data packet of the first set of packets is of the unqueuable class of service when an intermediate node (15) receiving the data packet should queue the data packet if a buffer for storing data packets awaiting transmission of the intermediate node (15) receiving the data packet is empty, and the intermediate node (15) receiving the data packet should not forward the data packet to the receiver node if the buffer for storing data packets awaiting transmission of the intermediate node (15) receiving the data packet is not empty.


     
    2. A method as claimed in Claim 1, further comprising the initial steps of:
    the source node (11) sending an initial set of packets, before the first set of packets, to the receiver node (18) over the data packet network (10) via the intermediate node (15), wherein the initial set of packets are of a class of service allowing them to be queued at the intermediate node (15).
     
    3. A method as claimed in Claim 2, wherein the rate the source node sends the first set of packets is higher than the rate the source node sends the initial set of packets.
     
    4. A method as claimed in any preceding claim, wherein the first set of packets contain dummy data.
     
    5. A method as claimed in any one of Claims 1 to 3, wherein the acknowledgement indicates that a packet of the first set of packets was prevented from being forwarded to the receiver node (18); and the second set of packets includes a retransmission of said prevented packet.
     
    6. A method as claimed in any one of Claims 1 to 4, further comprising the steps of:

    the source node (11) receiving a second acknowledgement of a second received packet of the first set of packets from the receiver node (18);

    the source node (11) determining a transmission rate between the source node (11) and receiver node (18) based on the rate the first and second acknowledgements are received at the source node (11);

    the source node (11) transmitting a second set of data packets to the receiver node (18) based on the determined transmission rate.


     
    7. A method of controlling a network node (15) in a data packet network (10), the network node (15) including a buffer for storing data packets awaiting transmission (20), the method comprising the steps of:

    receiving a first data packet from a first external network node (11);

    the method characterised by

    analysing the first data packet to determine if it is of an unqueuable class of service, wherein the first data packet is of the unqueuable class of service when

    the network node (15) should queue the first data packet if the network node's buffer (20) is empty, and

    the network node (15) should not forward the first data packet to a receiver node (18) if the network node's buffer (20) is not empty; and, if it is determined that the first data packet is of the unqueuable class of service,

    determining if at least one data packet is stored in the network node's buffer (20); and, if so,

    the first data packet is not transmitted.


     
    8. A method as claimed in Claim 7, wherein, if the first data packet is of the unqueuable class of service and there are no other data packets stored in the network node's buffer (20), the first data packet is forwarded to a second external network node (18).
     
    9. A network node configured to perform the method of any one of the preceding claims.
     
    10. A network including a network node as claimed in Claim 9.
     
    11. A non-transitory computer-readable storage medium storing a computer program or suite of computer programs, which upon execution by a computer system performs the method of any one of Claims 1 to 8.
     


    Ansprüche

    1. Verfahren zum Steuern von Paketen in einem Datenpaketnetzwerk, wobei das Verfahren die folgenden Schritte umfasst:

    Senden eines ersten Satzes von Paketen durch einen Quellknoten (11) via einen Zwischenknoten (15) über das Datenpaketnetzwerk (10) an einen Empfängerknoten (18);

    Empfangen einer ersten Bestätigung eines ersten empfangenen Pakets des ersten Satzes von Paketen durch den Quellknoten (11) vom Empfängerknoten (18); und

    Senden eines zweiten Satzes von Paketen durch den Quellknoten (11) über das Datenpaketnetzwerk (10) an den Empfängerknoten (18),

    wobei das Verfahren dadurch gekennzeichnet ist, dass der Quellknoten (11) den ersten Satz von Paketen als von einer nicht in eine Warteschlange stellbaren Dienstklasse markiert, wobei ein Datenpaket des ersten Satzes von Paketen von der nicht in eine Warteschlange stellbaren Dienstklasse ist, wenn

    ein Zwischenknoten (15), der das Datenpaket empfängt, das Datenpaket in eine Warteschlange stellen sollte, wenn ein Puffer zum Speichern von Datenpaketen, die auf eine Übertragung warten, des Zwischenknotens (15), der das Datenpaket empfängt, leer ist, und

    der Zwischenknoten (15), der das Datenpaket empfängt, das Datenpaket nicht zum Empfängerknoten weiterleiten sollte, wenn der Puffer zum Speichern von Datenpaketen, die auf eine Übertragung warten, des Zwischenknotens (15), der das Datenpaket empfängt, nicht leer ist.


     
    2. Verfahren nach Anspruch 1, das die folgenden anfänglichen Schritte umfasst:
    Senden eines anfänglichen Satzes von Paketen vor dem ersten Satz von Paketen durch den Quellknoten (11) via den Zwischenknoten (15) über das Datenpaketnetzwerk (10) an den Empfängerknoten (18), wobei der anfängliche Satz von Paketen von einer Dienstklasse ist, die es ihnen erlaubt, am Zwischenknoten (15) in eine Warteschlange gestellt zu werden.
     
    3. Verfahren nach Anspruch 2, wobei die Rate, mit der der Quellknoten den ersten Satz von Paketen sendet, höher ist als die Rate, mit der der Quellknoten den anfänglichen Satz von Paketen sendet.
     
    4. Verfahren nach einem der vorhergehenden Ansprüche, wobei der erste Satz von Paketen Dummydaten enthält.
     
    5. Verfahren nach einem der Ansprüche 1 bis 3, wobei die Bestätigung anzeigt, dass verhindert wurde, dass ein Paket des ersten Satzes von Paketen zum Empfängerknoten (18) weitergeleitet wird; und der zweite Satz von Paketen eine Neuübertragung des verhinderten Pakets beinhaltet.
     
    6. Verfahren nach einem der Ansprüche 1 bis 4, das ferner die folgenden Schritte umfasst:

    Empfangen einer zweiten Bestätigung eines zweiten empfangenen Pakets des ersten Satzes von Paketen durch den Quellknoten (11) vom Empfängerknoten (18);

    Bestimmen einer Übertragungsrate zwischen dem Quellknoten (11) und dem Empfängerknoten (18) durch den Quellknoten (11) auf Basis der Rate, mit der die erste und die zweite Bestätigung am Quellknoten (11) empfangen werden;

    Übertragen eines zweiten Satzes von Datenpaketen durch den Quellknoten (11) zum Empfängerknoten (18) auf Basis der bestimmten Übertragungsrate.


     
    7. Verfahren zum Steuern eines Netzwerkknotens (15) in einem Datenpaketnetzwerk (10), wobei der Netzwerkknoten (15) einen Puffer zum Speichern von Datenpaketen, die auf eine Übertragung (20) warten, beinhaltet, wobei das Verfahren die folgenden Schritte umfasst:

    Empfangen eines ersten Datenpakets von einem ersten externen Netzwerkknoten (11);

    wobei das Verfahren gekennzeichnet ist durch Analysieren des ersten Datenpakets, um zu bestimmen, ob es von einer nicht in eine Warteschlange stellbaren Dienstklasse ist, wobei das erste Datenpaket von der nicht in eine Warteschlange stellbaren Dienstklasse ist, wenn

    der Netzwerkknoten (15) das erste Datenpaket in eine Warteschlange stellen sollte, wenn der Puffer (20) des Netzwerkknotens leer ist, und

    der Netzwerkknoten (15) das erste Datenpaket nicht zu einem Empfängerknoten (18) weiterleiten sollte, wenn der Puffer (20) des Netzwerkknotens nicht leer ist; und

    wenn bestimmt wird, dass das erste Datenpaket von der nicht in eine Warteschlange stellbaren Dienstklasse ist,

    Bestimmen, ob mindestens ein Datenpaket im Puffer (20) des Netzwerkknotens gespeichert ist; und, wenn ja, das erste Datenpaket nicht übertragen wird.


     
    8. Verfahren nach Anspruch 7, wobei, wenn das erste Datenpaket von der nicht in eine Warteschlange stellbaren Dienstklasse ist und keine weiteren Datenpakete im Puffer (20) des Netzwerkknotens gespeichert sind, das erste Datenpaket zu einem zweiten externen Netzwerkknoten (18) weitergeleitet wird.
     
    9. Netzwerkknoten, der dazu ausgelegt ist, das Verfahren nach einem der vorhergehenden Ansprüche durchzuführen.
     
    10. Netzwerk, das einen Netzwerkknoten nach Anspruch 9 beinhaltet.
     
    11. Nichttransitorisches computerlesbares Speichermedium, auf dem ein Computerprogramm oder eine Gruppe von Computerprogrammen gespeichert ist, das bzw. die bei Ausführung durch ein Computersystem das Verfahren nach einem der Ansprüche 1 bis 8 durchführt.
     


    Revendications

    1. Procédé de commande de paquets dans un réseau de paquets de données, le procédé comprenant les étapes suivantes :

    un noeud source (11) envoyant un premier ensemble de paquets à un noeud récepteur (18) sur le réseau de paquets de données (10) via un noeud intermédiaire (15) ;

    le noeud source (11) recevant un premier accusé de réception d'un premier paquet reçu du premier ensemble de paquets à partir du noeud récepteur (18) ; et

    le noeud source (11) envoyant un second ensemble de paquets au noeud récepteur (18) sur le réseau de paquets de données (10),

    le procédé étant caractérisé en ce que le noeud source (11) marque le premier ensemble de paquets comme étant d'une classe de service ne pouvant pas être mis en file d'attente, un paquet de données du premier ensemble de paquets étant de la classe de service ne pouvant pas être mis en file d'attente lorsqu'un noeud intermédiaire (15) recevant le paquet de données doit mettre le paquet de données en attente si un tampon pour stocker les paquets de données attendant la transmission du noeud intermédiaire (15) recevant le paquet de données est vide, et

    le noeud intermédiaire (15) recevant le paquet de données ne doit pas transmettre le paquet de données au noeud récepteur si le tampon pour stocker des paquets de données en attente de transmission du noeud intermédiaire (15) recevant le paquet de données n'est pas vide.


     
    2. Procédé selon la revendication 1, comprenant en outre les étapes initiales suivantes :

    le noeud source (11) envoyant un ensemble initial de paquets, avant le premier ensemble de paquets, au noeud récepteur (18) sur le réseau de paquets de données (10) via le noeud intermédiaire (15), l'ensemble initial de paquets étant d'une classe de service leur permettant d'être mis en file d'attente au niveau du noeud intermédiaire (15).


     
    3. Procédé selon la revendication 2, la vitesse à laquelle le noeud source envoie le premier ensemble de paquets étant supérieure à la vitesse à laquelle le noeud source envoie l'ensemble initial de paquets.
     
    4. Procédé selon n'importe quelle revendication précédente, le premier ensemble de paquets contenant des données factices.
     
    5. Procédé selon l'une quelconque des revendications 1 à 3, l'accusé de réception indiquant qu'on a empêché un paquet du premier ensemble de paquets d'être transmis au noeud récepteur (18) ; et le second ensemble de paquets comprenant une retransmission dudit paquet dont la transmission a été empêchée.
     
    6. Procédé selon l'une quelconque des revendications 1 à 4, comprenant en outre les étapes suivantes :

    le noeud source (11) recevant un second accusé de réception d'un second paquet reçu du premier ensemble de paquets à partir du noeud récepteur (18) ;

    le noeud source (11) déterminant une vitesse de transmission entre le noeud source (11) et le noeud récepteur (18) sur la base de la vitesse à laquelle les premier et second accusés de réception sont reçus au niveau du noeud source (11) ;

    le noeud source (11) transmettant un second ensemble de paquets de données au noeud récepteur (18) sur la base de la vitesse de transmission déterminée.


     
    7. Procédé de commande d'un noeud de réseau (15) dans un réseau de paquets de données (10), le noeud de réseau (15) comprenant un tampon pour stocker des paquets de données en attente de transmission (20), le procédé comprenant les étapes de :

    la réception d'un premier paquet de données provenant d'un premier noeud de réseau externe (11) ;

    le procédé étant caractérisé par :

    l'analyse du premier paquet de données pour déterminer s'il est d'une classe de service ne pouvant pas être mis en file d'attente, le premier paquet de données étant de la classe de service ne pouvant pas être mis en file d'attente lorsque

    le noeud de réseau (15) doit mettre en file d'attente le premier paquet de données si le tampon de noeuds de réseau (20) est vide, et

    le noeud de réseau (15) ne doit pas transmettre le premier paquet de données à un noeud récepteur (18) si le tampon de noeuds de réseau (20) n'est pas vide ; et, s'il est déterminé que le premier paquet de données appartient à la classe de service ne pouvant pas être mis en file d'attente,

    la détermination du fait de savoir si au moins un paquet de données est stocké dans le tampon de noeuds de réseau (20) ; et, dans ce cas, le premier paquet de données n'est pas transmis.


     
    8. Procédé selon la revendication 7, si le premier paquet de données appartient à la classe de service ne pouvant pas être mis en file d'attente et qu'il n'y a pas d'autres paquets de données stockés dans le tampon de noeuds de réseau (20), le premier paquet de données étant transmis à un second noeud de réseau externe (18).
     
    9. Noeud de réseau configuré pour réaliser le procédé selon l'une quelconque des revendications précédentes.
     
    10. Réseau comprenant un noeud de réseau selon la revendication 9.
     
    11. Support de stockage non transitoire lisible par ordinateur stockant un programme informatique ou une suite de programmes informatiques qui, lors de l'exécution par un système informatique, réalise le procédé selon l'une quelconque des revendications 1 à 8 .
     




    Drawing






































    Cited references

    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