<?xml version="1.0" encoding="UTF-8"?>
<xliff xmlns="urn:oasis:names:tc:xliff:document:1.1" version="1.1">
  <file original="NoName" source-language="en" datatype="plaintext" target-language="en">
    <body>
      <trans-unit xml:space="preserve" approved="no" id="056e029045bd1427" weblate-flags="read-only">
        <source>Connecting two hosts</source>
        <target state="translated">Connecting two hosts</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">8</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="97a264c8a10fe94b" weblate-flags="read-only">
        <source>This is an unpolished draft of the third edition of this e-book. If you find any error or have suggestions to improve the text, please create an issue via https://github.com/CNP3/ebook/issues?milestone=1 or help us by providing pull requests to close the existing issues.</source>
        <target state="translated">This is an unpolished draft of the third edition of this e-book. If you find any error or have suggestions to improve the text, please create an issue via https://github.com/CNP3/ebook/issues?milestone=1 or help us by providing pull requests to close the existing issues.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">14</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="42a66419cedc5b69" weblate-flags="read-only">
        <source>The first step when building a network, even a worldwide network such as the Internet, is to connect two hosts together. This is illustrated in the figure below.</source>
        <target state="translated">The first step when building a network, even a worldwide network such as the Internet, is to connect two hosts together. This is illustrated in the figure below.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">17</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="a89abee31f36f813" weblate-flags="read-only">
        <source>To enable the two hosts to exchange information, they need to be linked together by some kind of physical media. Computer networks have used various types of physical media to exchange information, notably :</source>
        <target state="translated">To enable the two hosts to exchange information, they need to be linked together by some kind of physical media. Computer networks have used various types of physical media to exchange information, notably :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">31</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="90e4ec854b3fa9e3" weblate-flags="read-only">
        <source>`electrical cable`. Information can be transmitted over different types of electrical cables. The most common ones are the twisted pairs (that are used in the telephone network, but also in enterprise networks) and the coaxial cables (that are still used in cable TV networks, but are no longer used in enterprise networks). Some networking technologies operate over the classical electrical cable.</source>
        <target state="translated">`electrical cable`. Information can be transmitted over different types of electrical cables. The most common ones are the twisted pairs (that are used in the telephone network, but also in enterprise networks) and the coaxial cables (that are still used in cable TV networks, but are no longer used in enterprise networks). Some networking technologies operate over the classical electrical cable.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">33</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ed61de2efd87d2d7" weblate-flags="read-only">
        <source>`optical fiber`. Optical fibers are frequently used in public and enterprise networks when the distance between the communication devices is larger than one kilometer. There are two main types of optical fibers : multi-mode and single-mode. Multi-mode is much cheaper than single-mode fiber because a LED can be used to send a signal over a multi-mode fiber while a single-mode fiber must be driven by a laser. Due to the different modes of propagation of light, multi-mode fibers are limited to distances of a few kilometers while single-mode fibers can be used over distances greater than several tens of kilometers. In both cases, repeaters can be used to regenerate the optical signal at one endpoint of a fiber to send it over another fiber.</source>
        <target state="translated">`optical fiber`. Optical fibers are frequently used in public and enterprise networks when the distance between the communication devices is larger than one kilometer. There are two main types of optical fibers : multi-mode and single-mode. Multi-mode is much cheaper than single-mode fiber because a LED can be used to send a signal over a multi-mode fiber while a single-mode fiber must be driven by a laser. Due to the different modes of propagation of light, multi-mode fibers are limited to distances of a few kilometers while single-mode fibers can be used over distances greater than several tens of kilometers. In both cases, repeaters can be used to regenerate the optical signal at one endpoint of a fiber to send it over another fiber.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">34</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="62894cc47d66ab95" weblate-flags="read-only">
        <source>`wireless`. In this case, a radio signal is used to encode the information exchanged between the communicating devices. Many types of modulation techniques are used to send information over a wireless channel and there is lot of innovation in this field with new techniques appearing every year. While most wireless networks rely on radio signals, some use a laser that sends light pulses to a remote detector. These optical techniques allow to create point-to-point links while radio-based techniques can be used to build networks containing devices spread over a small geographical area.</source>
        <target state="translated">`wireless`. In this case, a radio signal is used to encode the information exchanged between the communicating devices. Many types of modulation techniques are used to send information over a wireless channel and there is lot of innovation in this field with new techniques appearing every year. While most wireless networks rely on radio signals, some use a laser that sends light pulses to a remote detector. These optical techniques allow to create point-to-point links while radio-based techniques can be used to build networks containing devices spread over a small geographical area.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">35</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="253a12125f09a240" weblate-flags="read-only">
        <source>The physical layer</source>
        <target state="translated">The physical layer</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">39</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="abd1859e0ecd26b7" weblate-flags="read-only">
        <source>These physical media can be used to exchange information once this information has been converted into a suitable electrical signal. Entire telecommunication courses and textbooks are devoted to the problem of converting analog or digital information into an electrical signal so that it can be transmitted over a given physical `link`. In this book, we only consider two very simple schemes that allow to transmit information over an electrical cable. This enables us to highlight the key problems when transmitting information over a physical link. We are only interested in techniques that allow transmitting digital information through the wire. Here, we will focus on the transmission of bits, i.e. either `0` or `1`.</source>
        <target state="translated">These physical media can be used to exchange information once this information has been converted into a suitable electrical signal. Entire telecommunication courses and textbooks are devoted to the problem of converting analog or digital information into an electrical signal so that it can be transmitted over a given physical `link`. In this book, we only consider two very simple schemes that allow to transmit information over an electrical cable. This enables us to highlight the key problems when transmitting information over a physical link. We are only interested in techniques that allow transmitting digital information through the wire. Here, we will focus on the transmission of bits, i.e. either `0` or `1`.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">41</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="6544ba38e1b03f2e" weblate-flags="read-only">
        <source>Bit rate</source>
        <target state="translated">Bit rate</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">44</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">49</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="8338f3ae4a89b61c" weblate-flags="read-only">
        <source>In computer networks, the bit rate of the physical layer is always expressed in bits per second. One Mbps is one million bits per second and one Gbps is one billion bits per second. This is in contrast with memory specifications that are usually expressed in bytes (8 bits), KiloBytes (1024 bytes) or MegaBytes (1048576 bytes). Transferring one MByte through a 1 Mbps link lasts 8.39 seconds.</source>
        <target state="translated">In computer networks, the bit rate of the physical layer is always expressed in bits per second. One Mbps is one million bits per second and one Gbps is one billion bits per second. This is in contrast with memory specifications that are usually expressed in bytes (8 bits), KiloBytes (1024 bytes) or MegaBytes (1048576 bytes). Transferring one MByte through a 1 Mbps link lasts 8.39 seconds.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">46</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d28a37d381c321c5" weblate-flags="read-only">
        <source>Bits per second</source>
        <target state="translated">Bits per second</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">49</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="f438a34f5e5c2659" weblate-flags="read-only">
        <source>1 Kbps</source>
        <target state="translated">1 Kbps</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">51</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="acd60575922ed818" weblate-flags="read-only">
        <source>:math:`10^3`</source>
        <target state="translated">:math:`10^3`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">51</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="30623f7a59f71552" weblate-flags="read-only">
        <source>1 Mbps</source>
        <target state="translated">1 Mbps</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">52</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5d1707ec74553605" weblate-flags="read-only">
        <source>:math:`10^6`</source>
        <target state="translated">:math:`10^6`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">52</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="6eaaf97d666f9119" weblate-flags="read-only">
        <source>1 Gbps</source>
        <target state="translated">1 Gbps</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">53</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="e88e6e161443146d" weblate-flags="read-only">
        <source>:math:`10^9`</source>
        <target state="translated">:math:`10^9`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">53</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="75b29a3ecf1b4b52" weblate-flags="read-only">
        <source>1 Tbps</source>
        <target state="translated">1 Tbps</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">54</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="2b4212296773ad7d" weblate-flags="read-only">
        <source>:math:`10^{12}`</source>
        <target state="translated">:math:`10^{12}`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">54</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="e6e0c7754f513265" weblate-flags="read-only">
        <source>To understand some of the principles behind the physical transmission of information, let us consider the simple case of an electrical wire that is used to transmit bits. Assume that the two communicating hosts want to transmit one thousand bits per second. To transmit these bits, the two hosts can agree on the following rules :</source>
        <target state="translated">To understand some of the principles behind the physical transmission of information, let us consider the simple case of an electrical wire that is used to transmit bits. Assume that the two communicating hosts want to transmit one thousand bits per second. To transmit these bits, the two hosts can agree on the following rules :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">59</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="74f263d5917359f1" weblate-flags="read-only">
        <source>On the sender side :</source>
        <target state="translated">On the sender side :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">63</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="e32ee478425548dd" weblate-flags="read-only">
        <source>set the voltage on the electrical wire at ``+5V`` during one millisecond to transmit a bit set to `1`</source>
        <target state="translated">set the voltage on the electrical wire at ``+5V`` during one millisecond to transmit a bit set to `1`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">62</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="20fb9cdaacf12deb" weblate-flags="read-only">
        <source>set the voltage on the electrical wire at ``-5V`` during one millisecond to transmit a bit set to `0`</source>
        <target state="translated">set the voltage on the electrical wire at ``-5V`` during one millisecond to transmit a bit set to `0`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">63</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="9de006cf6bf01adf" weblate-flags="read-only">
        <source>On the receiver side :</source>
        <target state="translated">On the receiver side :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">66</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="058a4c985925b993" weblate-flags="read-only">
        <source>every millisecond, record the voltage applied on the electrical wire. If the voltage is set to ``+5V``, record the reception of bit `1`. Otherwise, record the reception of bit `0`</source>
        <target state="translated">every millisecond, record the voltage applied on the electrical wire. If the voltage is set to ``+5V``, record the reception of bit `1`. Otherwise, record the reception of bit `0`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">66</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5f762d5e164a12e8" weblate-flags="read-only">
        <source>This transmission scheme has been used in some early networks. We use it as a basis to understand how hosts communicate.  From a Computer Science viewpoint, dealing with voltages is unusual. Computer scientists frequently rely on models that enable them to reason about the issues that they face without having to consider all implementation details. The physical transmission scheme described above can be represented by using a `time-sequence diagram`.</source>
        <target state="translated">This transmission scheme has been used in some early networks. We use it as a basis to understand how hosts communicate.  From a Computer Science viewpoint, dealing with voltages is unusual. Computer scientists frequently rely on models that enable them to reason about the issues that they face without having to consider all implementation details. The physical transmission scheme described above can be represented by using a `time-sequence diagram`.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">70</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="c25ebd167bb7049b" weblate-flags="read-only">
        <source>A `time-sequence diagram` describes the interactions between communicating hosts. By convention, the communicating hosts are represented in the left and right parts of the diagram while the electrical link occupies the middle of the diagram. In such a time-sequence diagram, time flows from the top to the bottom of the diagram. The transmission of one bit of information is represented by three arrows. Starting from the left, the first horizontal arrow represents the request to transmit one bit of information. This request is represented by a `primitive` which can be considered as a kind of procedure call. This primitive has one parameter (the bit being transmitted) and a name (`DATA.request` in this example). By convention, all primitives that are named `something.request` correspond to a request to transmit some information. The dashed arrow indicates the transmission of the corresponding electrical signal on the wire. Electrical and optical signals do not travel instantaneously. The diagonal dashed arrow indicates that it takes some time for the electrical signal to be transmitted from `Host A` to `Host B`. Upon reception of the electrical signal, the electronics on `Host B`'s network interface detects the voltage and converts it into a bit. This bit is delivered as a `DATA.indication` primitive. All primitives that are named `something.indication` correspond to the reception of some information. The dashed lines also represents the relationship between two (or more) primitives. Such a time-sequence diagram provides information about the ordering of the different primitives, but the distance between two primitives does not represent a precise amount of time.</source>
        <target state="translated">A `time-sequence diagram` describes the interactions between communicating hosts. By convention, the communicating hosts are represented in the left and right parts of the diagram while the electrical link occupies the middle of the diagram. In such a time-sequence diagram, time flows from the top to the bottom of the diagram. The transmission of one bit of information is represented by three arrows. Starting from the left, the first horizontal arrow represents the request to transmit one bit of information. This request is represented by a `primitive` which can be considered as a kind of procedure call. This primitive has one parameter (the bit being transmitted) and a name (`DATA.request` in this example). By convention, all primitives that are named `something.request` correspond to a request to transmit some information. The dashed arrow indicates the transmission of the corresponding electrical signal on the wire. Electrical and optical signals do not travel instantaneously. The diagonal dashed arrow indicates that it takes some time for the electrical signal to be transmitted from `Host A` to `Host B`. Upon reception of the electrical signal, the electronics on `Host B`'s network interface detects the voltage and converts it into a bit. This bit is delivered as a `DATA.indication` primitive. All primitives that are named `something.indication` correspond to the reception of some information. The dashed lines also represents the relationship between two (or more) primitives. Such a time-sequence diagram provides information about the ordering of the different primitives, but the distance between two primitives does not represent a precise amount of time.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">72</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="72d4d479b2b9cfc1" weblate-flags="read-only">
        <source>Time-sequence diagrams are useful when trying to understand the characteristics of a given communication scheme. When considering the above transmission scheme, it is useful to evaluate whether this scheme allows the two communicating hosts to reliably exchange information. A digital transmission is considered as reliable when a sequence of bits that is transmitted by a host is received correctly at the other end of the wire. In practice, achieving perfect reliability when transmitting information using the above scheme is difficult. Several problems can occur with such a transmission scheme.</source>
        <target state="translated">Time-sequence diagrams are useful when trying to understand the characteristics of a given communication scheme. When considering the above transmission scheme, it is useful to evaluate whether this scheme allows the two communicating hosts to reliably exchange information. A digital transmission is considered as reliable when a sequence of bits that is transmitted by a host is received correctly at the other end of the wire. In practice, achieving perfect reliability when transmitting information using the above scheme is difficult. Several problems can occur with such a transmission scheme.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">88</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="87d514452291e03d" weblate-flags="read-only">
        <source>The first problem is that electrical transmission can be affected by electromagnetic interference. Interference can have various sources including natural phenomenons (like thunderstorms, variations of the magnetic field,...) but also other electrical signals (such as interference from neighboring cables, interference from neighboring antennas,...). Due to these various types of interference, there is unfortunately no guarantee that when a host transmit one bit on a wire, the same bit is received at the other end. This is illustrated in the figure below where a `DATA.request(0)` on the left host leads to a `Data.indication(1)` on the right host.</source>
        <target state="translated">The first problem is that electrical transmission can be affected by electromagnetic interference. Interference can have various sources including natural phenomenons (like thunderstorms, variations of the magnetic field,...) but also other electrical signals (such as interference from neighboring cables, interference from neighboring antennas,...). Due to these various types of interference, there is unfortunately no guarantee that when a host transmit one bit on a wire, the same bit is received at the other end. This is illustrated in the figure below where a `DATA.request(0)` on the left host leads to a `Data.indication(1)` on the right host.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">91</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="9efe98ea25bdabfb" weblate-flags="read-only">
        <source>With the above transmission scheme, a bit is transmitted by setting the voltage on the electrical cable to a specific value during some period of time. We have seen that due to electromagnetic interference, the voltage measured by the receiver can differ from the voltage set by the transmitter. This is the main cause of transmission errors. However, this is not the only type of problem that can occur. Besides defining the voltages for bits `0` and `1`, the above transmission scheme also specifies the duration of each bit. If one million bits are sent every second, then each bit lasts 1 microsecond. On each host, the transmission (resp. the reception) of each bit is triggered by a local clock having a 1 MHz frequency. These clocks are the second source of problems when transmitting bits over a wire. Although the two clocks have the same specification, they run on different hosts, possibly at a different temperature and with a different source of energy. In practice, it is possible that the two clocks do not operate at exactly the same frequency. Assume that the clock of the transmitting host operates at exactly 1000000 Hz while the receiving clock operates at 999999 Hz. This is a very small difference between the two clocks. However, when using the clock to transmit bits, this difference is important. With its 1000000 Hz clock, the transmitting host will generate one million bits during a period of one second. During the same period, the receiving host will sense the wire 999999 times and thus will receive one bit less than the bits originally transmitted. This small difference in clock frequencies implies that bits can "disappear" during their transmission on an electrical cable. This is illustrated in the figure below.</source>
        <target state="translated">With the above transmission scheme, a bit is transmitted by setting the voltage on the electrical cable to a specific value during some period of time. We have seen that due to electromagnetic interference, the voltage measured by the receiver can differ from the voltage set by the transmitter. This is the main cause of transmission errors. However, this is not the only type of problem that can occur. Besides defining the voltages for bits `0` and `1`, the above transmission scheme also specifies the duration of each bit. If one million bits are sent every second, then each bit lasts 1 microsecond. On each host, the transmission (resp. the reception) of each bit is triggered by a local clock having a 1 MHz frequency. These clocks are the second source of problems when transmitting bits over a wire. Although the two clocks have the same specification, they run on different hosts, possibly at a different temperature and with a different source of energy. In practice, it is possible that the two clocks do not operate at exactly the same frequency. Assume that the clock of the transmitting host operates at exactly 1000000 Hz while the receiving clock operates at 999999 Hz. This is a very small difference between the two clocks. However, when using the clock to transmit bits, this difference is important. With its 1000000 Hz clock, the transmitting host will generate one million bits during a period of one second. During the same period, the receiving host will sense the wire 999999 times and thus will receive one bit less than the bits originally transmitted. This small difference in clock frequencies implies that bits can "disappear" during their transmission on an electrical cable. This is illustrated in the figure below.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">106</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="e4930e7a67740b3a" weblate-flags="read-only">
        <source>A similar reasoning applies when the clock of the sending host is slower than the clock of the receiving host. In this case, the receiver will sense more bits than the bits that have been transmitted by the sender. This is illustrated in the figure below where the second bit received on the right was not transmitted by the left host.</source>
        <target state="translated">A similar reasoning applies when the clock of the sending host is slower than the clock of the receiving host. In this case, the receiver will sense more bits than the bits that have been transmitted by the sender. This is illustrated in the figure below where the second bit received on the right was not transmitted by the left host.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">128</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="a44b36622acd1e84" weblate-flags="read-only">
        <source>From a Computer Science viewpoint, the physical transmission of information through a wire is often considered as a black box that allows transmitting bits. This black box is commonly referred to as the `physical layer service` and is represented by using the `DATA.request` and `DATA.indication` primitives introduced earlier. This physical layer service facilitates the sending and receiving of bits, by abstracting the technological details that are involved in the actual transmission of the bits as an electromagnetic signal. However, it is important to remember that the `physical layer service` is imperfect and has the following characteristics :</source>
        <target state="translated">From a Computer Science viewpoint, the physical transmission of information through a wire is often considered as a black box that allows transmitting bits. This black box is commonly referred to as the `physical layer service` and is represented by using the `DATA.request` and `DATA.indication` primitives introduced earlier. This physical layer service facilitates the sending and receiving of bits, by abstracting the technological details that are involved in the actual transmission of the bits as an electromagnetic signal. However, it is important to remember that the `physical layer service` is imperfect and has the following characteristics :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">150</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5b52e19382952f4f" weblate-flags="read-only">
        <source>the `Physical layer service` may change, e.g. due to electromagnetic interference, the value of a bit being transmitted</source>
        <target state="translated">the `Physical layer service` may change, e.g. due to electromagnetic interference, the value of a bit being transmitted</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">152</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="e956e7a0cd95bb4d" weblate-flags="read-only">
        <source>the `Physical layer service` may deliver `more` bits to the receiver than the bits sent by the sender</source>
        <target state="translated">the `Physical layer service` may deliver `more` bits to the receiver than the bits sent by the sender</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">153</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="efc818bfdaab5f42" weblate-flags="read-only">
        <source>the `Physical layer service` may deliver `fewer` bits to the receiver than the bits sent by the sender</source>
        <target state="translated">the `Physical layer service` may deliver `fewer` bits to the receiver than the bits sent by the sender</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">154</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5b566fb2ec048644" weblate-flags="read-only">
        <source>Many other types of encodings have been defined to transmit information over an electrical cable. All physical layers are able to send and receive physical symbols that represent values `0` and `1`. However, for various reasons that are outside the scope of this chapter, several physical layers exchange other physical symbols as well. For example, the Manchester encoding used in several physical layers can send four different symbols. The Manchester encoding is a differential encoding scheme in which time is divided into fixed-length periods. Each period is divided in two halves and two different voltage levels can  be applied. To send a symbol, the sender must set one of these two voltage levels during each half period. To send a `1` (resp. `0`), the sender must set a high (resp. low) voltage during the first half of the period and a low (resp. high) voltage during the second half. This encoding ensures that there will be a transition at the middle of each period and allows the receiver to synchronize its clock to the sender's clock. Apart from the encodings for `0` and `1`, the Manchester encoding also supports two additional symbols : `InvH` and `InvB`  where the same voltage level is used for the two half periods. By definition, these two symbols cannot appear inside a frame which is only composed of `0` and `1`. Some technologies use these special symbols as markers for the beginning or end of frames.</source>
        <target state="translated">Many other types of encodings have been defined to transmit information over an electrical cable. All physical layers are able to send and receive physical symbols that represent values `0` and `1`. However, for various reasons that are outside the scope of this chapter, several physical layers exchange other physical symbols as well. For example, the Manchester encoding used in several physical layers can send four different symbols. The Manchester encoding is a differential encoding scheme in which time is divided into fixed-length periods. Each period is divided in two halves and two different voltage levels can  be applied. To send a symbol, the sender must set one of these two voltage levels during each half period. To send a `1` (resp. `0`), the sender must set a high (resp. low) voltage during the first half of the period and a low (resp. high) voltage during the second half. This encoding ensures that there will be a transition at the middle of each period and allows the receiver to synchronize its clock to the sender's clock. Apart from the encodings for `0` and `1`, the Manchester encoding also supports two additional symbols : `InvH` and `InvB`  where the same voltage level is used for the two half periods. By definition, these two symbols cannot appear inside a frame which is only composed of `0` and `1`. Some technologies use these special symbols as markers for the beginning or end of frames.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">160</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="df7c834f1aa32604" weblate-flags="read-only">
        <source>Manchester encoding</source>
        <target state="translated">Manchester encoding</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">167</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ceee3826cc4e5c82" weblate-flags="read-only">
        <source>All the functions related to the physical transmission or information through a wire (or a wireless link) are usually known as the `physical layer`. The physical layer allows thus two or more entities that are directly attached to the same transmission medium to exchange bits. Being able to exchange bits is important as virtually any information can be encoded as a sequence of bits. Electrical engineers are used to processing streams of bits, but computer scientists usually prefer to deal with higher level concepts. A similar issue arises with file storage. Storage devices such as hard-disks also store streams of bits. There are hardware devices that process the bit stream produced by a hard-disk, but computer scientists have designed filesystems to allow applications to easily access such storage devices. These filesystems are typically divided into several layers as well. Hard-disks store sectors of 512 bytes or more. Unix filesystems group sectors in larger blocks that can contain data or `inodes` representing the structure of the filesystem. Finally, applications manipulate files and directories that are translated in blocks, sectors and eventually bits by the operating system.</source>
        <target state="translated">All the functions related to the physical transmission or information through a wire (or a wireless link) are usually known as the `physical layer`. The physical layer allows thus two or more entities that are directly attached to the same transmission medium to exchange bits. Being able to exchange bits is important as virtually any information can be encoded as a sequence of bits. Electrical engineers are used to processing streams of bits, but computer scientists usually prefer to deal with higher level concepts. A similar issue arises with file storage. Storage devices such as hard-disks also store streams of bits. There are hardware devices that process the bit stream produced by a hard-disk, but computer scientists have designed filesystems to allow applications to easily access such storage devices. These filesystems are typically divided into several layers as well. Hard-disks store sectors of 512 bytes or more. Unix filesystems group sectors in larger blocks that can contain data or `inodes` representing the structure of the filesystem. Finally, applications manipulate files and directories that are translated in blocks, sectors and eventually bits by the operating system.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">189</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="7246f29ca52554df" weblate-flags="read-only">
        <source>Computer networks use a similar approach. Each layer provides a service that is built above the underlying layer and is closer to the needs of the applications. The datalink layer builds upon the service provided by the physical layer. We will see that it also contains several functions.</source>
        <target state="translated">Computer networks use a similar approach. Each layer provides a service that is built above the underlying layer and is closer to the needs of the applications. The datalink layer builds upon the service provided by the physical layer. We will see that it also contains several functions.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">193</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="eb647155d40d487f" weblate-flags="read-only">
        <source>The datalink layer</source>
        <target state="translated">The datalink layer</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">197</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d4084cc28a440123" weblate-flags="read-only">
        <source>Computer scientists are usually not interested in exchanging bits between two hosts. They prefer to write software that deals with larger blocks of data in order to transmit messages or complete files. Thanks to the physical layer service, it is possible to send a continuous stream of bits between two hosts. This stream of bits can include logical blocks of data, but we need to be able to extract each block of data from the bit stream despite the imperfections of the physical layer. In many networks, the basic unit of information exchanged between two directly connected hosts is often called a `frame`. A `frame` can be defined as a sequence of bits that has a particular syntax or structure. We will see examples of such frames later in this chapter.</source>
        <target state="translated">Computer scientists are usually not interested in exchanging bits between two hosts. They prefer to write software that deals with larger blocks of data in order to transmit messages or complete files. Thanks to the physical layer service, it is possible to send a continuous stream of bits between two hosts. This stream of bits can include logical blocks of data, but we need to be able to extract each block of data from the bit stream despite the imperfections of the physical layer. In many networks, the basic unit of information exchanged between two directly connected hosts is often called a `frame`. A `frame` can be defined as a sequence of bits that has a particular syntax or structure. We will see examples of such frames later in this chapter.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">201</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="813f31e90d8d0a0c" weblate-flags="read-only">
        <source>To enable the transmission/reception of frames, the first problem to be solved is how to encode a frame as a sequence of bits, so that the receiver can easily recover the received frame despite the limitations of the physical layer.</source>
        <target state="translated">To enable the transmission/reception of frames, the first problem to be solved is how to encode a frame as a sequence of bits, so that the receiver can easily recover the received frame despite the limitations of the physical layer.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">203</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="f1c8c69eb4a6e7dd" weblate-flags="read-only">
        <source>If the physical layer were perfect, the problem would be very simple. We would simply need to define how to encode each frame as a sequence of consecutive bits. The receiver would then easily be able to extract the frames from the received bits. Unfortunately, the imperfections of the physical layer make this framing problem slightly more complex. Several solutions have been proposed and are used in practice in different network technologies.</source>
        <target state="translated">If the physical layer were perfect, the problem would be very simple. We would simply need to define how to encode each frame as a sequence of consecutive bits. The receiver would then easily be able to extract the frames from the received bits. Unfortunately, the imperfections of the physical layer make this framing problem slightly more complex. Several solutions have been proposed and are used in practice in different network technologies.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">208</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="26a910f58e32d3c7" weblate-flags="read-only">
        <source>Framing</source>
        <target state="translated">Framing</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">211</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d9bae1eb052edf01" weblate-flags="read-only">
        <source>The `framing` problem can be defined as : "`How does a sender encode frames so that the receiver can efficiently extract them from the stream of bits that it receives from the physical layer`".</source>
        <target state="translated">The `framing` problem can be defined as : "`How does a sender encode frames so that the receiver can efficiently extract them from the stream of bits that it receives from the physical layer`".</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">213</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="f5fe707de39c11b3" weblate-flags="read-only">
        <source>A first solution to this problem is to require the physical layer to remain idle for some time after the transmission of each frame. These idle periods can be detected by the receiver and serve as a marker to delineate frame boundaries. Unfortunately, this solution is not acceptable for two reasons. First, some physical layers cannot remain idle and always need to transmit bits. Second, inserting an idle period between frames decreases the maximum bit rate that can be achieved.</source>
        <target state="translated">A first solution to this problem is to require the physical layer to remain idle for some time after the transmission of each frame. These idle periods can be detected by the receiver and serve as a marker to delineate frame boundaries. Unfortunately, this solution is not acceptable for two reasons. First, some physical layers cannot remain idle and always need to transmit bits. Second, inserting an idle period between frames decreases the maximum bit rate that can be achieved.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">215</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="3b501a9171e07c12" weblate-flags="read-only">
        <source>Bit rate and bandwidth</source>
        <target state="translated">Bit rate and bandwidth</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">217</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="b184f6ddbad07dd2" weblate-flags="read-only">
        <source>Bit rate and bandwidth are often used to characterize the transmission capacity of the physical service. The original definition of `bandwidth &lt;https://www.merriam-webster.com/dictionary/bandwidth&gt;`_, as listed in the `Webster dictionary &lt;https://www.merriam-webster.com/dictionary&gt;`_ is `a range of radio frequencies which is occupied by a modulated carrier wave, which is assigned to a service, or over which a device can operate`. This definition corresponds to the characteristics of a given transmission medium or receiver. For example, the human ear is able to decode sounds in roughly the 0-20 KHz frequency range. By extension, bandwidth is also used to represent the capacity of a communication system in bits per second. For example, a Gigabit Ethernet link is theoretically capable of transporting one billion bits per second.</source>
        <target state="translated">Bit rate and bandwidth are often used to characterize the transmission capacity of the physical service. The original definition of `bandwidth &lt;https://www.merriam-webster.com/dictionary/bandwidth&gt;`_, as listed in the `Webster dictionary &lt;https://www.merriam-webster.com/dictionary&gt;`_ is `a range of radio frequencies which is occupied by a modulated carrier wave, which is assigned to a service, or over which a device can operate`. This definition corresponds to the characteristics of a given transmission medium or receiver. For example, the human ear is able to decode sounds in roughly the 0-20 KHz frequency range. By extension, bandwidth is also used to represent the capacity of a communication system in bits per second. For example, a Gigabit Ethernet link is theoretically capable of transporting one billion bits per second.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">219</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="800e724480be967a" weblate-flags="read-only">
        <source>Given that multi-symbol encodings cannot be used by all physical layers, a generic solution which can be used with any physical layer that is able to transmit and receive only bits `0` and `1` is required. This generic solution is called `stuffing` and two variants exist : `bit stuffing` and `character stuffing`. To enable a receiver to easily delineate the frame boundaries, these two techniques reserve special bit strings as frame boundary markers and encode the frames so that these special bit strings do not appear inside the frames.</source>
        <target state="translated">Given that multi-symbol encodings cannot be used by all physical layers, a generic solution which can be used with any physical layer that is able to transmit and receive only bits `0` and `1` is required. This generic solution is called `stuffing` and two variants exist : `bit stuffing` and `character stuffing`. To enable a receiver to easily delineate the frame boundaries, these two techniques reserve special bit strings as frame boundary markers and encode the frames so that these special bit strings do not appear inside the frames.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">224</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="6b983114ee10ca0c" weblate-flags="read-only">
        <source>`Bit stuffing` reserves the `01111110` bit string as the frame boundary marker and ensures that there will never be six consecutive `1` symbols transmitted by the physical layer inside a frame. With bit stuffing, a frame is sent as follows. First, the sender transmits the marker, i.e. `01111110`. Then, it sends all the bits of the frame and inserts an additional bit set to `0` after each sequence of five consecutive `1` bits. This ensures that the sent frame never contains a sequence of six consecutive bits set to `1`. As a consequence, the marker pattern cannot appear inside the frame sent. The marker is also sent to mark the end of the frame. The receiver performs the opposite to decode a received frame. It first detects the beginning of the frame thanks to the `01111110` marker. Then, it processes the received bits and counts the number of consecutive bits set to `1`. If a `0` follows five consecutive bits set to `1`, this bit is removed since it was inserted by the sender. If a `1` follows five consecutive bits sets to `1`, it indicates a marker if it is followed by a bit set to `0`. The table below illustrates the application of bit stuffing to some frames.</source>
        <target state="translated">`Bit stuffing` reserves the `01111110` bit string as the frame boundary marker and ensures that there will never be six consecutive `1` symbols transmitted by the physical layer inside a frame. With bit stuffing, a frame is sent as follows. First, the sender transmits the marker, i.e. `01111110`. Then, it sends all the bits of the frame and inserts an additional bit set to `0` after each sequence of five consecutive `1` bits. This ensures that the sent frame never contains a sequence of six consecutive bits set to `1`. As a consequence, the marker pattern cannot appear inside the frame sent. The marker is also sent to mark the end of the frame. The receiver performs the opposite to decode a received frame. It first detects the beginning of the frame thanks to the `01111110` marker. Then, it processes the received bits and counts the number of consecutive bits set to `1`. If a `0` follows five consecutive bits set to `1`, this bit is removed since it was inserted by the sender. If a `1` follows five consecutive bits sets to `1`, it indicates a marker if it is followed by a bit set to `0`. The table below illustrates the application of bit stuffing to some frames.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">226</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="0d94147670f318e3" weblate-flags="read-only">
        <source>Original frame</source>
        <target state="translated">Original frame</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">229</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">268</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="2100ad2c1c37a0a9" weblate-flags="read-only">
        <source>Transmitted frame</source>
        <target state="translated">Transmitted frame</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">229</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">268</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="11d14d9edc7b607b" weblate-flags="read-only">
        <source>0001001001001001001000011</source>
        <target state="translated">0001001001001001001000011</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">231</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="485ce7f7789afc1c" weblate-flags="read-only">
        <source>01111110000100100100100100100001101111110</source>
        <target state="translated">01111110000100100100100100100001101111110</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">231</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="21b319437ff79511" weblate-flags="read-only">
        <source>0110111111111111111110010</source>
        <target state="translated">0110111111111111111110010</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">232</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="f96f0ee8753ec328" weblate-flags="read-only">
        <source>01111110011011111011111011111011001001111110</source>
        <target state="translated">01111110011011111011111011111011001001111110</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">232</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5611687c3822c0f6" weblate-flags="read-only">
        <source>0111110</source>
        <target state="translated">0111110</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">233</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="cedc73448c3378e2" weblate-flags="read-only">
        <source>011111100111110001111110</source>
        <target state="translated">011111100111110001111110</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">233</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="88c5c5365d9324de" weblate-flags="read-only">
        <source>01111110</source>
        <target state="translated">01111110</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">234</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="a2da19c5ca45360b" weblate-flags="read-only">
        <source>0111111001111101001111110</source>
        <target state="translated">0111111001111101001111110</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">234</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="eb24e08079accf33" weblate-flags="read-only">
        <source>For example, consider the transmission of `0110111111111111111110010`. The sender will first send the `01111110` marker followed by `011011111`. After these five consecutive bits set to `1`, it inserts a bit set to `0` followed by `11111`. A new `0` is inserted, followed by `11111`. A new `0` is inserted followed by the end of the frame `110010` and the `01111110` marker.</source>
        <target state="translated">For example, consider the transmission of `0110111111111111111110010`. The sender will first send the `01111110` marker followed by `011011111`. After these five consecutive bits set to `1`, it inserts a bit set to `0` followed by `11111`. A new `0` is inserted, followed by `11111`. A new `0` is inserted followed by the end of the frame `110010` and the `01111110` marker.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">238</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="f9a966b7452cf928" weblate-flags="read-only">
        <source>`Bit stuffing` increases the number of bits required to transmit each frame. The worst case for bit stuffing is of course a long sequence of bits set to `1` inside the frame. If transmission errors occur, stuffed bits or markers can be in error. In these cases, the frame affected by the error and possibly the next frame will not be correctly decoded by the receiver, but it will be able to resynchronize itself at the next valid marker.</source>
        <target state="translated">`Bit stuffing` increases the number of bits required to transmit each frame. The worst case for bit stuffing is of course a long sequence of bits set to `1` inside the frame. If transmission errors occur, stuffed bits or markers can be in error. In these cases, the frame affected by the error and possibly the next frame will not be correctly decoded by the receiver, but it will be able to resynchronize itself at the next valid marker.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">241</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="33553124e9fa9c68" weblate-flags="read-only">
        <source>`Bit stuffing` can be easily implemented in hardware. However, implementing it in software is difficult given the complexity of performing bit manipulations in software. Software implementations prefer to process characters than bits, software-based datalink layers usually use `character stuffing`. This technique operates on frames that contain an integer number of characters. In computer networks, characters are usually encoded by relying on the :term:`ASCII` table. This table defines the encoding of various alphanumeric characters as a sequence of bits. :rfc:`20` provides the ASCII table that is used by many protocols on the Internet. For example, the table defines the following binary representations :</source>
        <target state="translated">`Bit stuffing` can be easily implemented in hardware. However, implementing it in software is difficult given the complexity of performing bit manipulations in software. Software implementations prefer to process characters than bits, software-based datalink layers usually use `character stuffing`. This technique operates on frames that contain an integer number of characters. In computer networks, characters are usually encoded by relying on the :term:`ASCII` table. This table defines the encoding of various alphanumeric characters as a sequence of bits. :rfc:`20` provides the ASCII table that is used by many protocols on the Internet. For example, the table defines the following binary representations :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">246</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="b67235644a98458c" weblate-flags="read-only">
        <source>`A` : `1000011` b</source>
        <target state="translated">`A` : `1000011` b</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">248</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="4e1617348d46e6c1" weblate-flags="read-only">
        <source>`0` : `0110000` b</source>
        <target state="translated">`0` : `0110000` b</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">249</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="26c9e432541f85f4" weblate-flags="read-only">
        <source>`z` : `1111010` b</source>
        <target state="translated">`z` : `1111010` b</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">250</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="1f1dadffca2cabd0" weblate-flags="read-only">
        <source>`@` : `1000000` b</source>
        <target state="translated">`@` : `1000000` b</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">251</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="6c8dddc019383287" weblate-flags="read-only">
        <source>`space` : `0100000` b</source>
        <target state="translated">`space` : `0100000` b</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">252</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="de0c84460a7f219b" weblate-flags="read-only">
        <source>In addition, the :term:`ASCII` table also defines several non-printable or control characters. These characters were designed to allow an application to control a printer or a terminal. These control characters include `CR` and `LF`, that are used to terminate a line, and the `BEL` character which causes the terminal to emit a sound.</source>
        <target state="translated">In addition, the :term:`ASCII` table also defines several non-printable or control characters. These characters were designed to allow an application to control a printer or a terminal. These control characters include `CR` and `LF`, that are used to terminate a line, and the `BEL` character which causes the terminal to emit a sound.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">254</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="f0f4e366a1ae18f9" weblate-flags="read-only">
        <source>`NUL`: `0000000` b</source>
        <target state="translated">`NUL`: `0000000` b</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">256</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d8a13aff13f581f9" weblate-flags="read-only">
        <source>`BEL`: `0000111` b</source>
        <target state="translated">`BEL`: `0000111` b</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">257</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="7806175f9d229e7a" weblate-flags="read-only">
        <source>`CR` : `0001101` b</source>
        <target state="translated">`CR` : `0001101` b</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">258</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ba9d4248e53642d7" weblate-flags="read-only">
        <source>`LF` : `0001010` b</source>
        <target state="translated">`LF` : `0001010` b</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">259</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="bcb018dd984b82b5" weblate-flags="read-only">
        <source>`DLE`: `0010000` b</source>
        <target state="translated">`DLE`: `0010000` b</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">260</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="dd97f706a7f39459" weblate-flags="read-only">
        <source>`STX`: `0000010` b</source>
        <target state="translated">`STX`: `0000010` b</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">261</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5e61b04ca4e44416" weblate-flags="read-only">
        <source>`ETX`: `0000011` b</source>
        <target state="translated">`ETX`: `0000011` b</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">262</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="8c7fbeabefda4e4f" weblate-flags="read-only">
        <source>Some characters are used as markers to delineate the frame boundaries. Many `character stuffing` techniques use the `DLE`, `STX` and `ETX` characters of the ASCII character set. `DLE STX` (resp. `DLE ETX`) is used to mark the beginning (end) of a frame. When transmitting a frame, the sender adds a `DLE` character after each transmitted `DLE` character. This ensures that none of the markers can appear inside the transmitted frame. The receiver detects the frame boundaries and removes the second `DLE` when it receives two consecutive `DLE` characters. For example, to transmit frame `1 2 3 DLE STX 4`, a sender will first send `DLE STX` as a marker, followed by `1 2 3 DLE`. Then, the sender transmits an additional `DLE` character followed by `STX 4` and the `DLE ETX` marker.</source>
        <target state="translated">Some characters are used as markers to delineate the frame boundaries. Many `character stuffing` techniques use the `DLE`, `STX` and `ETX` characters of the ASCII character set. `DLE STX` (resp. `DLE ETX`) is used to mark the beginning (end) of a frame. When transmitting a frame, the sender adds a `DLE` character after each transmitted `DLE` character. This ensures that none of the markers can appear inside the transmitted frame. The receiver detects the frame boundaries and removes the second `DLE` when it receives two consecutive `DLE` characters. For example, to transmit frame `1 2 3 DLE STX 4`, a sender will first send `DLE STX` as a marker, followed by `1 2 3 DLE`. Then, the sender transmits an additional `DLE` character followed by `STX 4` and the `DLE ETX` marker.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">264</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5c22fc86bf772560" weblate-flags="read-only">
        <source>**1** **2** **3** **4**</source>
        <target state="translated">**1** **2** **3** **4**</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">270</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="079c57310b4b1b95" weblate-flags="read-only">
        <source>`DLE STX` **1** **2** **3** **4** `DLE ETX`</source>
        <target state="translated">`DLE STX` **1** **2** **3** **4** `DLE ETX`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">270</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="4cf8937beb818ae6" weblate-flags="read-only">
        <source>**1** **2** **3** **DLE** **STX** **4**</source>
        <target state="translated">**1** **2** **3** **DLE** **STX** **4**</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">271</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="1d1324882485b126" weblate-flags="read-only">
        <source>`DLE STX` **1** **2** **3** **DLE** `DLE` **STX** `4` `DLE ETX`</source>
        <target state="translated">`DLE STX` **1** **2** **3** **DLE** `DLE` **STX** `4` `DLE ETX`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">271</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="f3bbe12a9a9afcda" weblate-flags="read-only">
        <source>**DLE STX DLE ETX**</source>
        <target state="translated">**DLE STX DLE ETX**</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">272</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="49c1bf4054951f90" weblate-flags="read-only">
        <source>`DLE STX` **DLE** `DLE` **STX** **DLE** `DLE` ETX** `DLE ETX`</source>
        <target state="translated">`DLE STX` **DLE** `DLE` **STX** **DLE** `DLE` ETX** `DLE ETX`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">272</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="bfd42528bb348ae5" weblate-flags="read-only">
        <source>`Character stuffing`, like bit stuffing, increases the length of the transmitted frames. For `character stuffing`, the worst frame is a frame containing many `DLE` characters. When transmission errors occur, the receiver may incorrectly decode one or two frames (e.g. if the errors occur in the markers). However, it will be able to resynchronize itself with the next correctly received markers.</source>
        <target state="translated">`Character stuffing`, like bit stuffing, increases the length of the transmitted frames. For `character stuffing`, the worst frame is a frame containing many `DLE` characters. When transmission errors occur, the receiver may incorrectly decode one or two frames (e.g. if the errors occur in the markers). However, it will be able to resynchronize itself with the next correctly received markers.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">275</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ed66c4c234d2b224" weblate-flags="read-only">
        <source>Bit stuffing and character stuffing allow recovering frames from a stream of bits or bytes. This framing mechanism provides a richer service than the physical layer. Through the framing service, one can send and receive complete frames. This framing service can also be represented by using the `DATA.request` and `DATA.indication` primitives. This is illustrated in the figure below, assuming hypothetical frames containing four useful bits and one bit of framing for graphical reasons.</source>
        <target state="translated">Bit stuffing and character stuffing allow recovering frames from a stream of bits or bytes. This framing mechanism provides a richer service than the physical layer. Through the framing service, one can send and receive complete frames. This framing service can also be represented by using the `DATA.request` and `DATA.indication` primitives. This is illustrated in the figure below, assuming hypothetical frames containing four useful bits and one bit of framing for graphical reasons.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">279</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="9a35e57aeabe5396" weblate-flags="read-only">
        <source>We can now build upon the framing mechanism to allow the hosts to exchange frames containing an integer number of bits or bytes. Once the framing problem has been solved, we can focus on designing a technique that allows reliably exchanging frames.</source>
        <target state="translated">We can now build upon the framing mechanism to allow the hosts to exchange frames containing an integer number of bits or bytes. Once the framing problem has been solved, we can focus on designing a technique that allows reliably exchanging frames.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">307</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="806227768c41d67e" weblate-flags="read-only">
        <source>Recovering from transmission errors</source>
        <target state="translated">Recovering from transmission errors</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">314</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="056a985ee2729448" weblate-flags="read-only">
        <source>In this section, we develop a reliable datalink protocol running above the physical layer service. To design this protocol, we first assume that the physical layer provides a perfect service. We will then develop solutions to recover from the transmission errors.</source>
        <target state="translated">In this section, we develop a reliable datalink protocol running above the physical layer service. To design this protocol, we first assume that the physical layer provides a perfect service. We will then develop solutions to recover from the transmission errors.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">316</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="3564c5c8a1f50889" weblate-flags="read-only">
        <source>The datalink layer is designed to send and receive frames on behalf of a user. We model these interactions by using the `DATA.req` and `DATA.ind` primitives. However, to simplify the presentation and to avoid confusion between a `DATA.req` primitive issued by the user of the datalink layer entity, and a `DATA.req` issued by the datalink layer entity itself, we will use the following terminology :</source>
        <target state="translated">The datalink layer is designed to send and receive frames on behalf of a user. We model these interactions by using the `DATA.req` and `DATA.ind` primitives. However, to simplify the presentation and to avoid confusion between a `DATA.req` primitive issued by the user of the datalink layer entity, and a `DATA.req` issued by the datalink layer entity itself, we will use the following terminology :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">318</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d852b0737f4d71e3" weblate-flags="read-only">
        <source>the interactions between the user and the datalink layer entity are represented by using the classical `DATA.req` and the `DATA.ind` primitives</source>
        <target state="translated">the interactions between the user and the datalink layer entity are represented by using the classical `DATA.req` and the `DATA.ind` primitives</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">320</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="b371b397747cdb13" weblate-flags="read-only">
        <source>the interactions between the datalink layer entity and the framing sub-layer are represented by using `send` instead of `DATA.req` and `recvd` instead of `DATA.ind`</source>
        <target state="translated">the interactions between the datalink layer entity and the framing sub-layer are represented by using `send` instead of `DATA.req` and `recvd` instead of `DATA.ind`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">321</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="afe3d27fd6bad24f" weblate-flags="read-only">
        <source>When running on top of a perfect framing sub-layer, a datalink entity can simply issue a `send(SDU)` upon arrival of a `DATA.req(SDU)` [#fsdu]_. Similarly, the receiver issues a `DATA.ind(SDU)` upon receipt of a `recvd(SDU)`. Such a simple protocol is sufficient when a single SDU is sent. This is illustrated in the figure below.</source>
        <target state="translated">When running on top of a perfect framing sub-layer, a datalink entity can simply issue a `send(SDU)` upon arrival of a `DATA.req(SDU)` [#fsdu]_. Similarly, the receiver issues a `DATA.ind(SDU)` upon receipt of a `recvd(SDU)`. Such a simple protocol is sufficient when a single SDU is sent. This is illustrated in the figure below.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">323</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="a54d55006f2853ae" weblate-flags="read-only">
        <source>Unfortunately, this is not always sufficient to ensure a reliable delivery of the SDUs. Consider the case where a client sends tens of SDUs to a server. If the server is faster than the client, it will be able to receive and process all the frames sent by the client and deliver their content to its user. However, if the server is slower than the client, problems may arise. The datalink entity contains buffers to store SDUs that have been received as a `Data.request` but have not yet been sent. If the application is faster than the physical link, the buffer may become full. At this point, the operating system suspends the application to let the datalink entity empty its transmission queue. The datalink entity also uses a buffer to store the received frames that have not yet been processed by the application. If the application is slow to process the data, this buffer may overflow and the datalink entity will not able to accept any additional frame. The buffers of the datalink entity have a limited size and if they overflow, the arriving frames will be discarded, even if they are correct.</source>
        <target state="translated">Unfortunately, this is not always sufficient to ensure a reliable delivery of the SDUs. Consider the case where a client sends tens of SDUs to a server. If the server is faster than the client, it will be able to receive and process all the frames sent by the client and deliver their content to its user. However, if the server is slower than the client, problems may arise. The datalink entity contains buffers to store SDUs that have been received as a `Data.request` but have not yet been sent. If the application is faster than the physical link, the buffer may become full. At this point, the operating system suspends the application to let the datalink entity empty its transmission queue. The datalink entity also uses a buffer to store the received frames that have not yet been processed by the application. If the application is slow to process the data, this buffer may overflow and the datalink entity will not able to accept any additional frame. The buffers of the datalink entity have a limited size and if they overflow, the arriving frames will be discarded, even if they are correct.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">342</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="4b882270de419300" weblate-flags="read-only">
        <source>To solve this problem, a reliable protocol must include a feedback mechanism that allows the receiver to inform the sender that it has processed a frame and that another one can be sent. This feedback is required even though there are no transmission errors. To include such a feedback, our reliable protocol must process two types of frames :</source>
        <target state="translated">To solve this problem, a reliable protocol must include a feedback mechanism that allows the receiver to inform the sender that it has processed a frame and that another one can be sent. This feedback is required even though there are no transmission errors. To include such a feedback, our reliable protocol must process two types of frames :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">344</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="226e0c52c2c17acc" weblate-flags="read-only">
        <source>data frames carrying a SDU</source>
        <target state="translated">data frames carrying a SDU</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">346</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="f5be2eaa9b3029fb" weblate-flags="read-only">
        <source>control frames carrying an acknowledgment indicating that the previous frames was correctly processed</source>
        <target state="translated">control frames carrying an acknowledgment indicating that the previous frames was correctly processed</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">347</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="064cadfa4d674a5e" weblate-flags="read-only">
        <source>These two types of frames can be distinguished by dividing the frame in two parts :</source>
        <target state="translated">These two types of frames can be distinguished by dividing the frame in two parts :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">349</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="503d93d466517b44" weblate-flags="read-only">
        <source>the `header` that contains one bit set to `0` in data frames and set to `1` in control frames</source>
        <target state="translated">the `header` that contains one bit set to `0` in data frames and set to `1` in control frames</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">351</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="82b3681c465ad560" weblate-flags="read-only">
        <source>the payload that contains the SDU supplied by the application</source>
        <target state="translated">the payload that contains the SDU supplied by the application</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">352</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="50eb9a4104657850" weblate-flags="read-only">
        <source>The datalink entity can then be modeled as a finite state machine, containing two states for the receiver and two states for the sender. The figure below provides a graphical representation of this state machine with the sender above and the receiver below.</source>
        <target state="translated">The datalink entity can then be modeled as a finite state machine, containing two states for the receiver and two states for the sender. The figure below provides a graphical representation of this state machine with the sender above and the receiver below.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">354</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ef62d4a26e8eeccf" weblate-flags="read-only">
        <source>The above FSM shows that the sender has to wait for an acknowledgment from the receiver before being able to transmit the next SDU.  The figure below illustrates the exchange of a few frames between two hosts.</source>
        <target state="translated">The above FSM shows that the sender has to wait for an acknowledgment from the receiver before being able to transmit the next SDU.  The figure below illustrates the exchange of a few frames between two hosts.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">388</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="c84dd783b54e5d94" weblate-flags="read-only">
        <source>Services and protocols</source>
        <target state="translated">Services and protocols</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">407</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="7cd959283f6df574" weblate-flags="read-only">
        <source>An important aspect to understand before studying computer networks is the difference between a *service* and a *protocol*. For this, it is useful to start with real world examples. The traditional Post provides a service where a postman delivers letters to recipients. The Post precisely defines which types of letters (size, weight, etc) can be delivered by using the Standard Mail service. Furthermore, the format of the envelope is specified (position of the sender and recipient addresses, position of the stamp). Someone who wants to send a letter must either place the letter at a Post Office or inside one of the dedicated mailboxes. The letter will then be collected and delivered to its final recipient. Note that for the regular service the Post usually does not guarantee the delivery of each particular letter. Some letters may be lost, and some letters are delivered to the wrong mailbox. If a letter is important, then the sender can use the registered service to ensure that the letter will be delivered to its recipient. Some Post services also provide an acknowledged service or an express mail service that is faster than the regular service.</source>
        <target state="translated">An important aspect to understand before studying computer networks is the difference between a *service* and a *protocol*. For this, it is useful to start with real world examples. The traditional Post provides a service where a postman delivers letters to recipients. The Post precisely defines which types of letters (size, weight, etc) can be delivered by using the Standard Mail service. Furthermore, the format of the envelope is specified (position of the sender and recipient addresses, position of the stamp). Someone who wants to send a letter must either place the letter at a Post Office or inside one of the dedicated mailboxes. The letter will then be collected and delivered to its final recipient. Note that for the regular service the Post usually does not guarantee the delivery of each particular letter. Some letters may be lost, and some letters are delivered to the wrong mailbox. If a letter is important, then the sender can use the registered service to ensure that the letter will be delivered to its recipient. Some Post services also provide an acknowledged service or an express mail service that is faster than the regular service.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">409</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="68eacebbd7c637ae" weblate-flags="read-only">
        <source>Reliable data transfer on top of an imperfect link</source>
        <target state="translated">Reliable data transfer on top of an imperfect link</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">424</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="66506f451ee5b0c6" weblate-flags="read-only">
        <source>The datalink layer must deal with the transmission errors. In practice, we mainly have to deal with two types of errors in the datalink layer :</source>
        <target state="translated">The datalink layer must deal with the transmission errors. In practice, we mainly have to deal with two types of errors in the datalink layer :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">426</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="12f9e3210bfb2988" weblate-flags="read-only">
        <source>Frames can be corrupted by transmission errors</source>
        <target state="translated">Frames can be corrupted by transmission errors</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">428</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="96464322d63910b1" weblate-flags="read-only">
        <source>Frames can be lost or unexpected frames can appear</source>
        <target state="translated">Frames can be lost or unexpected frames can appear</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">429</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="390e85da1069a1db" weblate-flags="read-only">
        <source>A first glance, loosing frames might seem strange on a single link. However, if we take framing into account, transmission errors can affect the frame delineation mechanism and make the frame unreadable. For the same reason, a receiver could receive two (likely invalid) frames after a sender has transmitted a single frame.</source>
        <target state="translated">A first glance, loosing frames might seem strange on a single link. However, if we take framing into account, transmission errors can affect the frame delineation mechanism and make the frame unreadable. For the same reason, a receiver could receive two (likely invalid) frames after a sender has transmitted a single frame.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">432</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="887ebce56ecb752f" weblate-flags="read-only">
        <source>To deal with these types of imperfections, reliable protocols rely on different types of mechanisms. The first problem is transmission errors. Data transmission on a physical link can be affected by the following errors :</source>
        <target state="translated">To deal with these types of imperfections, reliable protocols rely on different types of mechanisms. The first problem is transmission errors. Data transmission on a physical link can be affected by the following errors :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">434</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="6f051d9a3070aa81" weblate-flags="read-only">
        <source>random isolated errors where the value of a single bit has been modified due to a transmission error</source>
        <target state="translated">random isolated errors where the value of a single bit has been modified due to a transmission error</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">436</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="28294876d66d86fd" weblate-flags="read-only">
        <source>random burst errors where the values of `n` consecutive bits have been changed due to transmission errors</source>
        <target state="translated">random burst errors where the values of `n` consecutive bits have been changed due to transmission errors</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">437</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="18cb876bfc3f39f9" weblate-flags="read-only">
        <source>random bit creations and random bit removals where bits have been added or removed due to transmission errors</source>
        <target state="translated">random bit creations and random bit removals where bits have been added or removed due to transmission errors</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">438</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="bb9c6c46439aa23f" weblate-flags="read-only">
        <source>The only solution to protect against transmission errors is to add redundancy to the frames that are sent. `Information Theory` defines two mechanisms that can be used to transmit information over a transmission channel affected by random errors. These two mechanisms add redundancy to the transmitted information, to allow the receiver to detect or sometimes even correct transmission errors. A detailed discussion of these mechanisms is outside the scope of this chapter, but it is useful to consider a simple mechanism to understand its operation and its limitations.</source>
        <target state="translated">The only solution to protect against transmission errors is to add redundancy to the frames that are sent. `Information Theory` defines two mechanisms that can be used to transmit information over a transmission channel affected by random errors. These two mechanisms add redundancy to the transmitted information, to allow the receiver to detect or sometimes even correct transmission errors. A detailed discussion of these mechanisms is outside the scope of this chapter, but it is useful to consider a simple mechanism to understand its operation and its limitations.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">440</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d97e39ed51f9467a" weblate-flags="read-only">
        <source>`Information theory` defines `coding schemes`. There are different types of coding schemes, but let us focus on coding schemes that operate on binary strings. A coding scheme is a function that maps information encoded as a string of `m` bits into a string of `n` bits. The simplest coding scheme is the (even) parity coding. This coding scheme takes an `m` bits source string and produces an `m+1` bits coded string where the first `m` bits of the coded string are the bits of the source string and the last bit of the coded string is chosen such that the coded string will always contain an even number of bits set to `1`. For example :</source>
        <target state="translated">`Information theory` defines `coding schemes`. There are different types of coding schemes, but let us focus on coding schemes that operate on binary strings. A coding scheme is a function that maps information encoded as a string of `m` bits into a string of `n` bits. The simplest coding scheme is the (even) parity coding. This coding scheme takes an `m` bits source string and produces an `m+1` bits coded string where the first `m` bits of the coded string are the bits of the source string and the last bit of the coded string is chosen such that the coded string will always contain an even number of bits set to `1`. For example :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">442</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5b4b722e9ad63922" weblate-flags="read-only">
        <source>`1001` is encoded as `10010`</source>
        <target state="translated">`1001` is encoded as `10010`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">444</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="283724cd429a7432" weblate-flags="read-only">
        <source>`1101` is encoded as `11011`</source>
        <target state="translated">`1101` is encoded as `11011`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">445</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d946a127c2408d49" weblate-flags="read-only">
        <source>This parity scheme has been used in some RAMs as well as to encode characters sent over a serial line. It is easy to show that this coding scheme allows the receiver to detect a single transmission error, but it cannot correct it. However, if two or more bits are in error, the receiver may not always be able to detect the error.</source>
        <target state="translated">This parity scheme has been used in some RAMs as well as to encode characters sent over a serial line. It is easy to show that this coding scheme allows the receiver to detect a single transmission error, but it cannot correct it. However, if two or more bits are in error, the receiver may not always be able to detect the error.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">447</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="3fe32a86cd96e98a" weblate-flags="read-only">
        <source>Some coding schemes allow the receiver to correct some transmission errors. For example, consider the coding scheme that encodes each source bit as follows :</source>
        <target state="translated">Some coding schemes allow the receiver to correct some transmission errors. For example, consider the coding scheme that encodes each source bit as follows :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">449</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="07ea641b6f46d697" weblate-flags="read-only">
        <source>`1` is encoded as `111`</source>
        <target state="translated">`1` is encoded as `111`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">451</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d237afbb9cd1e8c2" weblate-flags="read-only">
        <source>`0` is encoded as `000`</source>
        <target state="translated">`0` is encoded as `000`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">452</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d8d8e9a9a23dfae4" weblate-flags="read-only">
        <source>For example, consider a sender that sends `111`. If there is one bit in error, the receiver could receive `011` or `101` or `110`. In these three cases, the receiver will decode the received bit pattern as a `1` since it contains a majority of bits set to `1`. If there are two bits in error, the receiver will not be able anymore to recover from the transmission error.</source>
        <target state="translated">For example, consider a sender that sends `111`. If there is one bit in error, the receiver could receive `011` or `101` or `110`. In these three cases, the receiver will decode the received bit pattern as a `1` since it contains a majority of bits set to `1`. If there are two bits in error, the receiver will not be able anymore to recover from the transmission error.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">454</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="b9a79429a8ce719c" weblate-flags="read-only">
        <source>This simple coding scheme forces the sender to transmit three bits for each source bit. However, it allows the receiver to correct single bit errors. More advanced coding systems that allow recovering from errors are used in several types of physical layers.</source>
        <target state="translated">This simple coding scheme forces the sender to transmit three bits for each source bit. However, it allows the receiver to correct single bit errors. More advanced coding systems that allow recovering from errors are used in several types of physical layers.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">456</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="303db662abb92bea" weblate-flags="read-only">
        <source>Besides framing, datalink layers also include mechanisms to detect and sometimes even recover from transmission errors. To allow a receiver to notice transmission errors, a sender must add some redundant information as an `error detection` code to the frame sent. This `error detection` code is computed by the sender on the frame that it transmits. When the receiver receives a frame with an error detection code, it recomputes it and verifies whether the received `error detection code` matches the computed `error detection code`. If they match, the frame is considered to be valid. Many error detection schemes exist and entire books have been written on the subject. A detailed discussion of these techniques is outside the scope of this book, and we will only discuss some examples to illustrate the key principles.</source>
        <target state="translated">Besides framing, datalink layers also include mechanisms to detect and sometimes even recover from transmission errors. To allow a receiver to notice transmission errors, a sender must add some redundant information as an `error detection` code to the frame sent. This `error detection` code is computed by the sender on the frame that it transmits. When the receiver receives a frame with an error detection code, it recomputes it and verifies whether the received `error detection code` matches the computed `error detection code`. If they match, the frame is considered to be valid. Many error detection schemes exist and entire books have been written on the subject. A detailed discussion of these techniques is outside the scope of this book, and we will only discuss some examples to illustrate the key principles.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">458</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="834628bd7f7a44cc" weblate-flags="read-only">
        <source>To understand `error detection codes`, let us consider two devices that exchange bit strings containing `N` bits. To allow the receiver to detect a transmission error, the sender converts each string of `N` bits into a string of `N+r` bits. Usually, the `r` redundant bits are added at the beginning or the end of the transmitted bit string, but some techniques interleave redundant bits with the original bits. An `error detection code` can be defined as a function that computes the `r` redundant bits corresponding to each string of `N` bits. The simplest error detection code is the parity bit. There are two types of parity schemes : even and odd parity. With the `even` (resp. `odd`) parity scheme, the redundant bit is chosen so that an even (resp. odd) number of bits are set to `1` in the transmitted bit string of `N+r` bits. The receiver can easily recompute the parity of each received bit string and discard the strings with an invalid parity. The parity scheme is often used when 7-bit characters are exchanged. In this case, the eighth bit is often a parity bit. The table below shows the parity bits that are computed for bit strings containing three bits.</source>
        <target state="translated">To understand `error detection codes`, let us consider two devices that exchange bit strings containing `N` bits. To allow the receiver to detect a transmission error, the sender converts each string of `N` bits into a string of `N+r` bits. Usually, the `r` redundant bits are added at the beginning or the end of the transmitted bit string, but some techniques interleave redundant bits with the original bits. An `error detection code` can be defined as a function that computes the `r` redundant bits corresponding to each string of `N` bits. The simplest error detection code is the parity bit. There are two types of parity schemes : even and odd parity. With the `even` (resp. `odd`) parity scheme, the redundant bit is chosen so that an even (resp. odd) number of bits are set to `1` in the transmitted bit string of `N+r` bits. The receiver can easily recompute the parity of each received bit string and discard the strings with an invalid parity. The parity scheme is often used when 7-bit characters are exchanged. In this case, the eighth bit is often a parity bit. The table below shows the parity bits that are computed for bit strings containing three bits.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">460</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="0eb60136c56de55b" weblate-flags="read-only">
        <source>3 bits string</source>
        <target state="translated">3 bits string</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">463</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="a5063c9e1ecf323f" weblate-flags="read-only">
        <source>Odd parity</source>
        <target state="translated">Odd parity</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">463</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="fd8c3c3d44fc7786" weblate-flags="read-only">
        <source>Even parity</source>
        <target state="translated">Even parity</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">463</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="cebce96cf46cfc11" weblate-flags="read-only">
        <source>000</source>
        <target state="translated">000</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">465</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">482</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="dfbd4c12eb9e51b0" weblate-flags="read-only">
        <source>1</source>
        <target state="translated">1</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">465</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">466</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">467</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">468</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">469</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">470</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">471</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">472</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">486</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">487</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">488</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">489</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="eba030ebb7f9b8e1" weblate-flags="read-only">
        <source>0</source>
        <target state="translated">0</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">465</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">466</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">467</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">468</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">469</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">470</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">471</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">472</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">482</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">483</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">484</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">485</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="3718a43712eb855f" weblate-flags="read-only">
        <source>001</source>
        <target state="translated">001</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">466</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">483</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="e8f83601acada220" weblate-flags="read-only">
        <source>010</source>
        <target state="translated">010</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">467</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">484</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="afaa0dead75b1f6f" weblate-flags="read-only">
        <source>100</source>
        <target state="translated">100</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">468</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">485</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="72d656772f2452ae" weblate-flags="read-only">
        <source>111</source>
        <target state="translated">111</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">469</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">486</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="db231dea66900c64" weblate-flags="read-only">
        <source>110</source>
        <target state="translated">110</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">470</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">487</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="140a197ebf27d954" weblate-flags="read-only">
        <source>101</source>
        <target state="translated">101</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">471</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">488</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="52ed52ed46fb7c26" weblate-flags="read-only">
        <source>011</source>
        <target state="translated">011</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">472</context>
        </context-group>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">489</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="11de8f20b509141a" weblate-flags="read-only">
        <source>The parity bit allows a receiver to detect transmission errors that have affected a single bit among the transmitted `N+r` bits. If there are two or more bits in error, the receiver may not necessarily be able to detect the transmission error. More powerful error detection schemes have been defined. The Cyclical Redundancy Checks (CRC) are widely used in datalink layer protocols. An N-bits CRC can detect all transmission errors affecting a burst of less than N bits in the transmitted frame and all transmission errors that affect an odd number of bits. Additional details about CRCs may be found in [Williams1993]_.</source>
        <target state="translated">The parity bit allows a receiver to detect transmission errors that have affected a single bit among the transmitted `N+r` bits. If there are two or more bits in error, the receiver may not necessarily be able to detect the transmission error. More powerful error detection schemes have been defined. The Cyclical Redundancy Checks (CRC) are widely used in datalink layer protocols. An N-bits CRC can detect all transmission errors affecting a burst of less than N bits in the transmitted frame and all transmission errors that affect an odd number of bits. Additional details about CRCs may be found in [Williams1993]_.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">475</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ffb3fa7530124be1" weblate-flags="read-only">
        <source>It is also possible to design a code that allows the receiver to correct transmission errors. The simplest `error correction code` is the triple modular redundancy (TMR). To transmit a bit set to `1` (resp. `0`), the sender transmits `111` (resp. `000`). When there are no transmission errors, the receiver can decode `111` as `1`. If transmission errors have affected a single bit, the receiver performs majority voting as shown in the table below. This scheme allows the receiver to correct all transmission errors that affect a single bit.</source>
        <target state="translated">It is also possible to design a code that allows the receiver to correct transmission errors. The simplest `error correction code` is the triple modular redundancy (TMR). To transmit a bit set to `1` (resp. `0`), the sender transmits `111` (resp. `000`). When there are no transmission errors, the receiver can decode `111` as `1`. If transmission errors have affected a single bit, the receiver performs majority voting as shown in the table below. This scheme allows the receiver to correct all transmission errors that affect a single bit.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">477</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="24e7fcea74b192ad" weblate-flags="read-only">
        <source>Received bits</source>
        <target state="translated">Received bits</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">480</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="c5728608f9596188" weblate-flags="read-only">
        <source>Decoded bit</source>
        <target state="translated">Decoded bit</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">480</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="e886500e589bf11f" weblate-flags="read-only">
        <source>Other more powerful error correction codes have been proposed and are used in some applications. The `Hamming Code &lt;https://en.wikipedia.org/wiki/Hamming_code&gt;`_ is a clever combination of parity bits that provides error detection and correction capabilities.</source>
        <target state="translated">Other more powerful error correction codes have been proposed and are used in some applications. The `Hamming Code &lt;https://en.wikipedia.org/wiki/Hamming_code&gt;`_ is a clever combination of parity bits that provides error detection and correction capabilities.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">492</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="4468eb54d0346d83" weblate-flags="read-only">
        <source>Reliable protocols use error detection schemes, but none of the widely used reliable protocols rely on error correction schemes. To detect errors, a frame is usually divided into two parts :</source>
        <target state="translated">Reliable protocols use error detection schemes, but none of the widely used reliable protocols rely on error correction schemes. To detect errors, a frame is usually divided into two parts :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">495</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="818b9fbf71e21cd0" weblate-flags="read-only">
        <source>a `header` that contains the fields used by the reliable protocol to ensure reliable delivery. The header contains a checksum or Cyclical Redundancy Check (CRC) [Williams1993]_ that is used to detect transmission errors</source>
        <target state="translated">a `header` that contains the fields used by the reliable protocol to ensure reliable delivery. The header contains a checksum or Cyclical Redundancy Check (CRC) [Williams1993]_ that is used to detect transmission errors</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">497</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="2534ed9e37ecd9e9" weblate-flags="read-only">
        <source>a `payload` that contains the user data</source>
        <target state="translated">a `payload` that contains the user data</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">498</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="f875ad623884f9b1" weblate-flags="read-only">
        <source>Some headers also include a `length` field, which indicates the total length of the frame or the length of the payload.</source>
        <target state="translated">Some headers also include a `length` field, which indicates the total length of the frame or the length of the payload.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">500</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="c01d18ff55e549ac" weblate-flags="read-only">
        <source>The simplest error detection scheme is the checksum. A checksum is basically an arithmetic sum of all the bytes that a frame is composed of. There are different types of checksums. For example, an eight bit checksum can be computed as the arithmetic sum of all the bytes of (both the header and trailer of) the frame. The checksum is computed by the sender before sending the frame and the receiver verifies the checksum upon frame reception. The receiver discards frames received with an invalid checksum. Checksums can be easily implemented in software, but their error detection capabilities are limited. Cyclical Redundancy Checks (CRC) have better error detection capabilities [SGP98]_, but require more CPU when implemented in software.</source>
        <target state="translated">The simplest error detection scheme is the checksum. A checksum is basically an arithmetic sum of all the bytes that a frame is composed of. There are different types of checksums. For example, an eight bit checksum can be computed as the arithmetic sum of all the bytes of (both the header and trailer of) the frame. The checksum is computed by the sender before sending the frame and the receiver verifies the checksum upon frame reception. The receiver discards frames received with an invalid checksum. Checksums can be easily implemented in software, but their error detection capabilities are limited. Cyclical Redundancy Checks (CRC) have better error detection capabilities [SGP98]_, but require more CPU when implemented in software.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">502</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="827792252ca2df02" weblate-flags="read-only">
        <source>Checksums, CRCs,...</source>
        <target state="translated">Checksums, CRCs,...</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">508</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="aa5cae7cfabea160" weblate-flags="read-only">
        <source>Most of the protocols in the TCP/IP protocol suite rely on the simple Internet checksum in order to verify that a received packet has not been affected by transmission errors. Despite its popularity and ease of implementation, the Internet checksum is not the only available checksum mechanism. Cyclical Redundancy Checks (CRC_) are very powerful error detection schemes that are used notably on disks, by many datalink layer protocols and file formats such as ``zip`` or ``png``. They can easily be implemented efficiently in hardware and have better error-detection capabilities than the Internet checksum [SGP98]_ . However, CRCs are sometimes considered to be too CPU-intensive for software implementations and other checksum mechanisms are preferred. The TCP/IP community chose the Internet checksum, the OSI community chose the Fletcher checksum [Sklower89]_. Nowadays there are efficient techniques to quickly compute CRCs in software [Feldmeier95]_.</source>
        <target state="translated">Most of the protocols in the TCP/IP protocol suite rely on the simple Internet checksum in order to verify that a received packet has not been affected by transmission errors. Despite its popularity and ease of implementation, the Internet checksum is not the only available checksum mechanism. Cyclical Redundancy Checks (CRC_) are very powerful error detection schemes that are used notably on disks, by many datalink layer protocols and file formats such as ``zip`` or ``png``. They can easily be implemented efficiently in hardware and have better error-detection capabilities than the Internet checksum [SGP98]_ . However, CRCs are sometimes considered to be too CPU-intensive for software implementations and other checksum mechanisms are preferred. The TCP/IP community chose the Internet checksum, the OSI community chose the Fletcher checksum [Sklower89]_. Nowadays there are efficient techniques to quickly compute CRCs in software [Feldmeier95]_.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">510</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ae917a659aff0e43" weblate-flags="read-only">
        <source>Since the receiver sends an acknowledgment after having received each data frame, the simplest solution to deal with losses is to use a retransmission timer. When the sender sends a frame, it starts a retransmission timer. The value of this retransmission timer should be larger than the `round-trip-time`, i.e. the delay between the transmission of a data frame and the reception of the corresponding acknowledgment. When the retransmission timer expires, the sender assumes that the data frame has been lost and retransmits it. This is illustrated in the figure below.</source>
        <target state="translated">Since the receiver sends an acknowledgment after having received each data frame, the simplest solution to deal with losses is to use a retransmission timer. When the sender sends a frame, it starts a retransmission timer. The value of this retransmission timer should be larger than the `round-trip-time`, i.e. the delay between the transmission of a data frame and the reception of the corresponding acknowledgment. When the retransmission timer expires, the sender assumes that the data frame has been lost and retransmits it. This is illustrated in the figure below.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">524</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="7c410cbe63ef5027" weblate-flags="read-only">
        <source>Unfortunately, retransmission timers alone are not sufficient to recover from losses. Let us consider, as an example, the situation depicted below where an acknowledgment is lost. In this case, the sender retransmits the data frame that has not been acknowledged. However, as illustrated in the figure below, the receiver considers the retransmission as a new frame whose payload must be delivered to its user.</source>
        <target state="translated">Unfortunately, retransmission timers alone are not sufficient to recover from losses. Let us consider, as an example, the situation depicted below where an acknowledgment is lost. In this case, the sender retransmits the data frame that has not been acknowledged. However, as illustrated in the figure below, the receiver considers the retransmission as a new frame whose payload must be delivered to its user.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">555</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="e54bc16a263de964" weblate-flags="read-only">
        <source>To solve this problem, datalink protocols associate a `sequence number` to each data frame. This `sequence number` is one of the fields found in the header of data frames. We use the notation `D(x,...)` to indicate a data frame whose sequence number field is set to value `x`. The acknowledgments also contain a sequence number indicating the data frames that it is acknowledging. We use `OKx` to indicate an acknowledgment frame that confirms the reception of `D(x,...)`. The sequence number is encoded as a bit string of fixed length. The simplest reliable protocol is the Alternating Bit Protocol (ABP).</source>
        <target state="translated">To solve this problem, datalink protocols associate a `sequence number` to each data frame. This `sequence number` is one of the fields found in the header of data frames. We use the notation `D(x,...)` to indicate a data frame whose sequence number field is set to value `x`. The acknowledgments also contain a sequence number indicating the data frames that it is acknowledging. We use `OKx` to indicate an acknowledgment frame that confirms the reception of `D(x,...)`. The sequence number is encoded as a bit string of fixed length. The simplest reliable protocol is the Alternating Bit Protocol (ABP).</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">586</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5c9c63a036f6f1d7" weblate-flags="read-only">
        <source>The Alternating Bit Protocol uses a single bit to encode the sequence number. It can be implemented easily. The sender (resp. the receiver) only require a four-state (resp. three-state) Finite State Machine.</source>
        <target state="translated">The Alternating Bit Protocol uses a single bit to encode the sequence number. It can be implemented easily. The sender (resp. the receiver) only require a four-state (resp. three-state) Finite State Machine.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">590</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="9d54701a601f5be8" weblate-flags="read-only">
        <source>The initial state of the sender is `Wait for D(0,...)`. In this state, the sender waits for a `Data.request`. The first data frame that it sends uses sequence number `0`. After having sent this frame, the sender waits for an `OK0` acknowledgment. A frame is retransmitted upon expiration of the retransmission timer or if an acknowledgment with an incorrect sequence number has been received.</source>
        <target state="translated">The initial state of the sender is `Wait for D(0,...)`. In this state, the sender waits for a `Data.request`. The first data frame that it sends uses sequence number `0`. After having sent this frame, the sender waits for an `OK0` acknowledgment. A frame is retransmitted upon expiration of the retransmission timer or if an acknowledgment with an incorrect sequence number has been received.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">643</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d82a0a2f47c0154f" weblate-flags="read-only">
        <source>The receiver first waits for `D(0,...)`. If the frame contains a correct `CRC`, it passes the SDU to its user and sends `OK0`. If the frame contains an invalid CRC, it is immediately discarded. Then, the receiver waits for `D(1,...)`. In this state, it may receive a duplicate `D(0,...)` or a data frame with an invalid CRC. In both cases, it returns an `OK0` frame to allow the sender to recover from the possible loss of the previous `OK0` frame.</source>
        <target state="translated">The receiver first waits for `D(0,...)`. If the frame contains a correct `CRC`, it passes the SDU to its user and sends `OK0`. If the frame contains an invalid CRC, it is immediately discarded. Then, the receiver waits for `D(1,...)`. In this state, it may receive a duplicate `D(0,...)` or a data frame with an invalid CRC. In both cases, it returns an `OK0` frame to allow the sender to recover from the possible loss of the previous `OK0` frame.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">645</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="87a861c80bcc67d7" weblate-flags="read-only">
        <source>Dealing with corrupted frames</source>
        <target state="translated">Dealing with corrupted frames</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">696</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="8be589acb2005670" weblate-flags="read-only">
        <source>The receiver FSM of the Alternating bit protocol discards all frames that contain an invalid CRC. This is the safest approach since the received frame can be completely different from the frame sent by the remote host. A receiver should not attempt at extracting information from a corrupted frame because it cannot know which portion of the frame has been affected by the error.</source>
        <target state="translated">The receiver FSM of the Alternating bit protocol discards all frames that contain an invalid CRC. This is the safest approach since the received frame can be completely different from the frame sent by the remote host. A receiver should not attempt at extracting information from a corrupted frame because it cannot know which portion of the frame has been affected by the error.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">698</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="291f6db211a34064" weblate-flags="read-only">
        <source>The figure below illustrates the operation of the alternating bit protocol.</source>
        <target state="translated">The figure below illustrates the operation of the alternating bit protocol.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">701</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="2b304b98b7ce54bb" weblate-flags="read-only">
        <source>The Alternating Bit Protocol can recover from the losses of data or control frames. This is illustrated in the two figures below. The first figure shows the loss of one data frame.</source>
        <target state="translated">The Alternating Bit Protocol can recover from the losses of data or control frames. This is illustrated in the two figures below. The first figure shows the loss of one data frame.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">731</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="c1ca95c625c11779" weblate-flags="read-only">
        <source>The second figure illustrates how the hosts handle the loss of one control frame.</source>
        <target state="translated">The second figure illustrates how the hosts handle the loss of one control frame.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">758</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ed20d6e5f26067e0" weblate-flags="read-only">
        <source>The Alternating Bit Protocol can recover from transmission errors and frame losses. However, it has one important drawback. Consider two hosts that are directly connected by a 50 Kbits/sec satellite link that has a 250 milliseconds propagation delay. If these hosts send 1000 bits frames, then the maximum throughput that can be achieved by the alternating bit protocol is one frame every :math:`20+250+250=520` milliseconds if we ignore the transmission time of the acknowledgment. This is less than 2 Kbits/sec !</source>
        <target state="translated">The Alternating Bit Protocol can recover from transmission errors and frame losses. However, it has one important drawback. Consider two hosts that are directly connected by a 50 Kbits/sec satellite link that has a 250 milliseconds propagation delay. If these hosts send 1000 bits frames, then the maximum throughput that can be achieved by the alternating bit protocol is one frame every :math:`20+250+250=520` milliseconds if we ignore the transmission time of the acknowledgment. This is less than 2 Kbits/sec !</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">794</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="2d45e5897573934c" weblate-flags="read-only">
        <source>Go-back-n and selective repeat</source>
        <target state="translated">Go-back-n and selective repeat</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">804</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="4d1e85fe8474fc89" weblate-flags="read-only">
        <source>To overcome the performance limitations of the alternating bit protocol, reliable protocols rely on `pipelining`. This technique allows a sender to transmit several consecutive frames without being forced to wait for an acknowledgment after each frame. Each data frame contains a sequence number encoded as an `n` bits field.</source>
        <target state="translated">To overcome the performance limitations of the alternating bit protocol, reliable protocols rely on `pipelining`. This technique allows a sender to transmit several consecutive frames without being forced to wait for an acknowledgment after each frame. Each data frame contains a sequence number encoded as an `n` bits field.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">806</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="a624e328f4ebce29" weblate-flags="read-only">
        <source>Pipelining improves the performance of reliable protocols</source>
        <target state="translated">Pipelining improves the performance of reliable protocols</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">812</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="7092fd54821c6668" weblate-flags="read-only">
        <source>`Pipelining` allows the sender to transmit frames at a higher rate. However this higher transmission rate may overload the receiver. In this case, the frames sent by the sender will not be correctly received by their final destination. The reliable protocols that rely on pipelining allow the sender to transmit `W` unacknowledged frames before being forced to wait for an acknowledgment from the receiving entity.</source>
        <target state="translated">`Pipelining` allows the sender to transmit frames at a higher rate. However this higher transmission rate may overload the receiver. In this case, the frames sent by the sender will not be correctly received by their final destination. The reliable protocols that rely on pipelining allow the sender to transmit `W` unacknowledged frames before being forced to wait for an acknowledgment from the receiving entity.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">814</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="ed5c0d0773712025" weblate-flags="read-only">
        <source>This is implemented by using a `sliding window`. The sliding window is the set of consecutive sequence numbers that the sender can use when transmitting frames without being forced to wait for an acknowledgment. The figure below shows a sliding window containing five frames (`6,7,8,9` and `10`). Two of these sequence numbers (`6` and `7`) have been used to send frames and only three sequence numbers (`8`, `9` and `10`) remain in the sliding window. The sliding window is said to be closed once all sequence numbers contained in the sliding window have been used.</source>
        <target state="translated">This is implemented by using a `sliding window`. The sliding window is the set of consecutive sequence numbers that the sender can use when transmitting frames without being forced to wait for an acknowledgment. The figure below shows a sliding window containing five frames (`6,7,8,9` and `10`). Two of these sequence numbers (`6` and `7`) have been used to send frames and only three sequence numbers (`8`, `9` and `10`) remain in the sliding window. The sliding window is said to be closed once all sequence numbers contained in the sliding window have been used.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">816</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="865aacb636443222" weblate-flags="read-only">
        <source>The sliding window</source>
        <target state="translated">The sliding window</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">822</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5e22c56bf863e3ba" weblate-flags="read-only">
        <source>The figure below illustrates the operation of the sliding window. It uses a sliding window of three frames. The sender can thus transmit three frames before being forced to wait for an acknowledgment. The sliding window moves to the higher sequence numbers upon the reception of each acknowledgment. When the first acknowledgment (`OK0`) is received, it enables the sender to move its sliding window to the right and sequence number `3` becomes available. This sequence number is used later to transmit the frame containing `d`.</source>
        <target state="translated">The figure below illustrates the operation of the sliding window. It uses a sliding window of three frames. The sender can thus transmit three frames before being forced to wait for an acknowledgment. The sliding window moves to the higher sequence numbers upon the reception of each acknowledgment. When the first acknowledgment (`OK0`) is received, it enables the sender to move its sliding window to the right and sequence number `3` becomes available. This sequence number is used later to transmit the frame containing `d`.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">824</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="94508ce1de957dc9" weblate-flags="read-only">
        <source>Sliding window example</source>
        <target state="translated">Sliding window example</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">831</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="13f9c9861e2e7138" weblate-flags="read-only">
        <source>In practice, as the frame header includes an `n` bits field to encode the sequence number, only the sequence numbers between :math:`0` and :math:`2^{n}-1` can be used. This implies that, during a long transfer, the same sequence number will be used for different frames and the sliding window will wrap. This is illustrated in the figure below assuming that `2` bits are used to encode the sequence number in the frame header. Note that upon reception of `OK1`, the sender slides its window and can use sequence number `0` again.</source>
        <target state="translated">In practice, as the frame header includes an `n` bits field to encode the sequence number, only the sequence numbers between :math:`0` and :math:`2^{n}-1` can be used. This implies that, during a long transfer, the same sequence number will be used for different frames and the sliding window will wrap. This is illustrated in the figure below assuming that `2` bits are used to encode the sequence number in the frame header. Note that upon reception of `OK1`, the sender slides its window and can use sequence number `0` again.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">834</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="534fa44e3b134f87" weblate-flags="read-only">
        <source>Utilisation of the sliding window with modulo arithmetic</source>
        <target state="translated">Utilisation of the sliding window with modulo arithmetic</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">841</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5fb91609c40ab341" weblate-flags="read-only">
        <source>Unfortunately, frame losses do not disappear because a reliable protocol uses a sliding window. To recover from losses, a sliding window protocol must define :</source>
        <target state="translated">Unfortunately, frame losses do not disappear because a reliable protocol uses a sliding window. To recover from losses, a sliding window protocol must define :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">846</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="5b8edb7475a1e682" weblate-flags="read-only">
        <source>a heuristic to detect frame losses</source>
        <target state="translated">a heuristic to detect frame losses</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">848</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="cedfeec798ce35ab" weblate-flags="read-only">
        <source>a `retransmission strategy` to retransmit the lost frames</source>
        <target state="translated">a `retransmission strategy` to retransmit the lost frames</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">849</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d58cd14fcaae1d19" weblate-flags="read-only">
        <source>The simplest sliding window protocol uses the `go-back-n` recovery. Intuitively, `go-back-n` operates as follows. A `go-back-n` receiver is as simple as possible. It only accepts the frames that arrive in-sequence. A `go-back-n` receiver discards any out-of-sequence frame that it receives. When `go-back-n` receives a data frame, it always returns an acknowledgment containing the sequence number of the last in-sequence frame that it has received. This acknowledgment is said to be `cumulative`. When a `go-back-n` receiver sends an acknowledgment for sequence number `x`, it implicitly acknowledges the reception of all frames whose sequence number is earlier than `x`. A key advantage of these cumulative acknowledgments is that it is easy to recover from the loss of an acknowledgment. Consider for example a `go-back-n` receiver that received frames `1`, `2` and `3`. It sent `OK1`, `OK2` and `OK3`. Unfortunately, `OK1` and `OK2` were lost. Thanks to the cumulative acknowledgments, when the sender receives `OK3`, it knows that all three frames have been correctly received.</source>
        <target state="translated">The simplest sliding window protocol uses the `go-back-n` recovery. Intuitively, `go-back-n` operates as follows. A `go-back-n` receiver is as simple as possible. It only accepts the frames that arrive in-sequence. A `go-back-n` receiver discards any out-of-sequence frame that it receives. When `go-back-n` receives a data frame, it always returns an acknowledgment containing the sequence number of the last in-sequence frame that it has received. This acknowledgment is said to be `cumulative`. When a `go-back-n` receiver sends an acknowledgment for sequence number `x`, it implicitly acknowledges the reception of all frames whose sequence number is earlier than `x`. A key advantage of these cumulative acknowledgments is that it is easy to recover from the loss of an acknowledgment. Consider for example a `go-back-n` receiver that received frames `1`, `2` and `3`. It sent `OK1`, `OK2` and `OK3`. Unfortunately, `OK1` and `OK2` were lost. Thanks to the cumulative acknowledgments, when the sender receives `OK3`, it knows that all three frames have been correctly received.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">854</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="0390c9fe105f9922" weblate-flags="read-only">
        <source>The figure below shows the FSM of a simple `go-back-n` receiver. This receiver uses two variables : `lastack` and `next`. `next` is the next expected sequence number and `lastack` the sequence number of the last data frame that has been acknowledged. The receiver only accepts the frame that are received in sequence. `maxseq` is the number of different sequence numbers (:math:`2^n`).</source>
        <target state="translated">The figure below shows the FSM of a simple `go-back-n` receiver. This receiver uses two variables : `lastack` and `next`. `next` is the next expected sequence number and `lastack` the sequence number of the last data frame that has been acknowledged. The receiver only accepts the frame that are received in sequence. `maxseq` is the number of different sequence numbers (:math:`2^n`).</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">856</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="04d78fd0d67cdd1b" weblate-flags="read-only">
        <source>A `go-back-n` sender is also very simple. It uses a sending buffer that can store an entire sliding window of frames [#fsizesliding]_. The frames are sent with increasing sequence numbers (modulo `maxseq`). The sender must wait for an acknowledgment once its sending buffer is full. When a `go-back-n` sender receives an acknowledgment, it removes from the sending buffer all the acknowledged frames and uses a retransmission timer to detect frame losses. A simple `go-back-n` sender maintains one retransmission timer per connection. This timer is started when the first frame is sent. When the `go-back-n sender` receives an acknowledgment, it restarts the retransmission timer only if there are still unacknowledged frames in its sending buffer. When the retransmission timer expires, the `go-back-n` sender assumes that all the unacknowledged frames currently stored in its sending buffer have been lost. It thus retransmits all the unacknowledged frames in the buffer and restarts its retransmission timer.</source>
        <target state="translated">A `go-back-n` sender is also very simple. It uses a sending buffer that can store an entire sliding window of frames [#fsizesliding]_. The frames are sent with increasing sequence numbers (modulo `maxseq`). The sender must wait for an acknowledgment once its sending buffer is full. When a `go-back-n` sender receives an acknowledgment, it removes from the sending buffer all the acknowledged frames and uses a retransmission timer to detect frame losses. A simple `go-back-n` sender maintains one retransmission timer per connection. This timer is started when the first frame is sent. When the `go-back-n sender` receives an acknowledgment, it restarts the retransmission timer only if there are still unacknowledged frames in its sending buffer. When the retransmission timer expires, the `go-back-n` sender assumes that all the unacknowledged frames currently stored in its sending buffer have been lost. It thus retransmits all the unacknowledged frames in the buffer and restarts its retransmission timer.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">890</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="f0f76cdf753c5ef6" weblate-flags="read-only">
        <source>The operation of `go-back-n` is illustrated in the figure below. In this figure, note that upon reception of the out-of-sequence frame `D(2,c)`, the receiver returns a cumulative acknowledgment `C(OK,0)` that acknowledges all the frames that have been received in sequence. The lost frame is retransmitted upon the expiration of the retransmission timer.</source>
        <target state="translated">The operation of `go-back-n` is illustrated in the figure below. In this figure, note that upon reception of the out-of-sequence frame `D(2,c)`, the receiver returns a cumulative acknowledgment `C(OK,0)` that acknowledges all the frames that have been received in sequence. The lost frame is retransmitted upon the expiration of the retransmission timer.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">932</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="347f6f1ae26a138e" weblate-flags="read-only">
        <source>Go-back-n : example</source>
        <target state="translated">Go-back-n : example</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">938</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="48f04843b294ccc2" weblate-flags="read-only">
        <source>The main advantage of `go-back-n` is that it can be easily implemented, and it can also provide good performance when only a few frames are lost. However, when there are many losses, the performance of `go-back-n` quickly drops for two reasons :</source>
        <target state="translated">The main advantage of `go-back-n` is that it can be easily implemented, and it can also provide good performance when only a few frames are lost. However, when there are many losses, the performance of `go-back-n` quickly drops for two reasons :</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">941</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="299425bb2a503d81" weblate-flags="read-only">
        <source>the `go-back-n` receiver does not accept out-of-sequence frames</source>
        <target state="translated">the `go-back-n` receiver does not accept out-of-sequence frames</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">943</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="6b29b1783337734e" weblate-flags="read-only">
        <source>the `go-back-n` sender retransmits all unacknowledged frames once it has detected a loss</source>
        <target state="translated">the `go-back-n` sender retransmits all unacknowledged frames once it has detected a loss</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">944</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="35f35cf3a5d8f233" weblate-flags="read-only">
        <source>`Selective repeat` is a better strategy to recover from losses. Intuitively, `selective repeat` allows the receiver to accept out-of-sequence frames. Furthermore, when a `selective repeat` sender detects losses, it only retransmits the frames that have been lost and not the frames that have already been correctly received.</source>
        <target state="translated">`Selective repeat` is a better strategy to recover from losses. Intuitively, `selective repeat` allows the receiver to accept out-of-sequence frames. Furthermore, when a `selective repeat` sender detects losses, it only retransmits the frames that have been lost and not the frames that have already been correctly received.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">951</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="bf647fff63e8397b" weblate-flags="read-only">
        <source>A `selective repeat` receiver maintains a sliding window of `W` frames and stores in a buffer the out-of-sequence frames that it receives. The figure below shows a five-frame receive window on a receiver that has already received frames `7` and `9`.</source>
        <target state="translated">A `selective repeat` receiver maintains a sliding window of `W` frames and stores in a buffer the out-of-sequence frames that it receives. The figure below shows a five-frame receive window on a receiver that has already received frames `7` and `9`.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">953</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="dd84fd633c41cb28" weblate-flags="read-only">
        <source>The receiving window with selective repeat</source>
        <target state="translated">The receiving window with selective repeat</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">959</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="c512baa1c7c05c46" weblate-flags="read-only">
        <source>A `selective repeat` receiver discards all frames having an invalid CRC, and maintains the variable `lastack` as the sequence number of the last in-sequence frame that it has received. The receiver always includes the value of `lastack` in the acknowledgments that it sends. Some protocols also allow the `selective repeat` receiver to acknowledge the out-of-sequence frames that it has received. This can be done for example by placing the list of the correctly received, but out-of-sequence frames in the acknowledgments together with the `lastack` value.</source>
        <target state="translated">A `selective repeat` receiver discards all frames having an invalid CRC, and maintains the variable `lastack` as the sequence number of the last in-sequence frame that it has received. The receiver always includes the value of `lastack` in the acknowledgments that it sends. Some protocols also allow the `selective repeat` receiver to acknowledge the out-of-sequence frames that it has received. This can be done for example by placing the list of the correctly received, but out-of-sequence frames in the acknowledgments together with the `lastack` value.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">961</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="d839eeb8bbe3f05c" weblate-flags="read-only">
        <source>When a `selective repeat` receiver receives a data frame, it first verifies whether the frame is inside its receiving window. If yes, the frame is placed in the receive buffer. If not, the received frame is discarded and an acknowledgment containing `lastack` is sent to the sender. The receiver then removes all consecutive frames starting at `lastack` (if any) from the receive buffer. The payloads of these frames are delivered to the user, `lastack` and the receiving window are updated, and an acknowledgment acknowledging the last frame received in sequence is sent.</source>
        <target state="translated">When a `selective repeat` receiver receives a data frame, it first verifies whether the frame is inside its receiving window. If yes, the frame is placed in the receive buffer. If not, the received frame is discarded and an acknowledgment containing `lastack` is sent to the sender. The receiver then removes all consecutive frames starting at `lastack` (if any) from the receive buffer. The payloads of these frames are delivered to the user, `lastack` and the receiving window are updated, and an acknowledgment acknowledging the last frame received in sequence is sent.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">963</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="dcc8a8280d2b67fa" weblate-flags="read-only">
        <source>The `selective repeat` sender maintains a sending buffer that can store up to `W` unacknowledged frames. These frames are sent as long as the sending buffer is not full. Several implementations of a `selective repeat` sender are possible. A simple implementation associates one retransmission timer to each frame. The timer is started when the frame is sent and canceled upon reception of an acknowledgment that covers this frame. When a retransmission timer expires, the corresponding frame is retransmitted and this retransmission timer is restarted. When an acknowledgment is received, all the frames that are covered by this acknowledgment are removed from the sending buffer and the sliding window is updated.</source>
        <target state="translated">The `selective repeat` sender maintains a sending buffer that can store up to `W` unacknowledged frames. These frames are sent as long as the sending buffer is not full. Several implementations of a `selective repeat` sender are possible. A simple implementation associates one retransmission timer to each frame. The timer is started when the frame is sent and canceled upon reception of an acknowledgment that covers this frame. When a retransmission timer expires, the corresponding frame is retransmitted and this retransmission timer is restarted. When an acknowledgment is received, all the frames that are covered by this acknowledgment are removed from the sending buffer and the sliding window is updated.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">965</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="eac6c1e574f53297" weblate-flags="read-only">
        <source>The figure below illustrates the operation of `selective repeat` when frames are lost. In this figure, `C(OK,x)` is used to indicate that all frames, up to and including sequence number `x` have been received correctly.</source>
        <target state="translated">The figure below illustrates the operation of `selective repeat` when frames are lost. In this figure, `C(OK,x)` is used to indicate that all frames, up to and including sequence number `x` have been received correctly.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">967</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="162150a9081e1247" weblate-flags="read-only">
        <source>Selective repeat : example</source>
        <target state="translated">Selective repeat : example</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">973</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="4be7bb9b6904370b" weblate-flags="read-only">
        <source>Pure cumulative acknowledgments work well with the `go-back-n` strategy. However, with only cumulative acknowledgments a `selective repeat` sender cannot easily determine which frames have been correctly received after a data frame has been lost. For example, in the figure above, the second `C(OK,0)` does not inform explicitly the sender of the reception of `D(2,c)` and the sender could retransmit this frame although it has already been received. A possible solution to improve the performance of `selective repeat` is to provide additional information about the received frames in the acknowledgments that are returned by the receiver. For example, the receiver could add in the returned acknowledgment the list of the sequence numbers of all frames that have already been received. Such acknowledgments are sometimes called `selective acknowledgments`. This is illustrated in the figure above.</source>
        <target state="translated">Pure cumulative acknowledgments work well with the `go-back-n` strategy. However, with only cumulative acknowledgments a `selective repeat` sender cannot easily determine which frames have been correctly received after a data frame has been lost. For example, in the figure above, the second `C(OK,0)` does not inform explicitly the sender of the reception of `D(2,c)` and the sender could retransmit this frame although it has already been received. A possible solution to improve the performance of `selective repeat` is to provide additional information about the received frames in the acknowledgments that are returned by the receiver. For example, the receiver could add in the returned acknowledgment the list of the sequence numbers of all frames that have already been received. Such acknowledgments are sometimes called `selective acknowledgments`. This is illustrated in the figure above.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">977</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="7f0942685cc0792b" weblate-flags="read-only">
        <source>In the figure above, when the sender receives `C(OK,0,[2])`, it knows that all frames up to and including `D(0,...)` have been correctly received. It also knows that frame `D(2,...)` has been received and can cancel the retransmission timer associated to this frame. However, this frame should not be removed from the sending buffer before the reception of a cumulative acknowledgment (`C(OK,2)` in the figure above) that covers this frame.</source>
        <target state="translated">In the figure above, when the sender receives `C(OK,0,[2])`, it knows that all frames up to and including `D(0,...)` have been correctly received. It also knows that frame `D(2,...)` has been received and can cancel the retransmission timer associated to this frame. However, this frame should not be removed from the sending buffer before the reception of a cumulative acknowledgment (`C(OK,2)` in the figure above) that covers this frame.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">986</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="f52d9d1b2e40d4fc" weblate-flags="read-only">
        <source>Maximum window size with `go-back-n` and `selective repeat`</source>
        <target state="translated">Maximum window size with `go-back-n` and `selective repeat`</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">990</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="1943139f84356e6e" weblate-flags="read-only">
        <source>A reliable protocol that uses `n` bits to encode its sequence number can send up to :math:`2^n` successive frames. However, to ensure a reliable delivery of the frames, `go-back-n` and `selective repeat` cannot use a sending window of :math:`2^n` frames. Consider first `go-back-n` and assume that a sender sends :math:`2^n` frames. These frames are received in-sequence by the destination, but all the returned acknowledgments are lost. The sender will retransmit all frames. These frames will all be accepted by the receiver and delivered a second time to the user. It is easy to see that this problem can be avoided if the maximum size of the sending window is :math:`{2^n}-1` frames. A similar problem occurs with `selective repeat`. However, as the receiver accepts out-of-sequence frames, a sending window of :math:`{2^n}-1` frames is not sufficient to ensure a reliable delivery. It can be easily shown that to avoid this problem, a `selective repeat` sender cannot use a window that is larger than :math:`\frac{2^n}{2}` frames.</source>
        <target state="translated">A reliable protocol that uses `n` bits to encode its sequence number can send up to :math:`2^n` successive frames. However, to ensure a reliable delivery of the frames, `go-back-n` and `selective repeat` cannot use a sending window of :math:`2^n` frames. Consider first `go-back-n` and assume that a sender sends :math:`2^n` frames. These frames are received in-sequence by the destination, but all the returned acknowledgments are lost. The sender will retransmit all frames. These frames will all be accepted by the receiver and delivered a second time to the user. It is easy to see that this problem can be avoided if the maximum size of the sending window is :math:`{2^n}-1` frames. A similar problem occurs with `selective repeat`. However, as the receiver accepts out-of-sequence frames, a sending window of :math:`{2^n}-1` frames is not sufficient to ensure a reliable delivery. It can be easily shown that to avoid this problem, a `selective repeat` sender cannot use a window that is larger than :math:`\frac{2^n}{2}` frames.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">992</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="7c09c416af3b2650" weblate-flags="read-only">
        <source>Reliable protocols often need to send data in both directions. To reduce the overhead caused by the acknowledgments, most reliable protocols use `piggybacking`. Thanks to this technique, a datalink entity can place the acknowledgments and the receive window that it advertises for the opposite direction of the data flow inside the header of the data frames that it sends. The main advantage of piggybacking is that it reduces the overhead as it is not necessary to send a complete frame to carry an acknowledgment. This is illustrated in the figure below where the acknowledgment number is underlined in the data frames. Piggybacking is only used when data flows in both directions. A receiver will generate a pure acknowledgment when it does not send data in the opposite direction as shown in the bottom of the figure.</source>
        <target state="translated">Reliable protocols often need to send data in both directions. To reduce the overhead caused by the acknowledgments, most reliable protocols use `piggybacking`. Thanks to this technique, a datalink entity can place the acknowledgments and the receive window that it advertises for the opposite direction of the data flow inside the header of the data frames that it sends. The main advantage of piggybacking is that it reduces the overhead as it is not necessary to send a complete frame to carry an acknowledgment. This is illustrated in the figure below where the acknowledgment number is underlined in the data frames. Piggybacking is only used when data flows in both directions. A receiver will generate a pure acknowledgment when it does not send data in the opposite direction as shown in the bottom of the figure.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">1038</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="33a41c7b1a0b8d5d" weblate-flags="read-only">
        <source>Piggybacking example</source>
        <target state="translated">Piggybacking example</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">1044</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="c4216746468d4eb9" weblate-flags="read-only">
        <source>SDU is the acronym of Service Data Unit. We use it as a generic term to represent the data that is transported by a protocol.</source>
        <target state="translated">SDU is the acronym of Service Data Unit. We use it as a generic term to represent the data that is transported by a protocol.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">1052</context>
        </context-group>
      </trans-unit>
      <trans-unit xml:space="preserve" approved="no" id="7d87167e8bc8abed" weblate-flags="read-only">
        <source>The size of the sliding window can be either fixed for a given protocol or negotiated during the connection establishment phase. Some protocols allow to change the maximum window size during the data transfer. We will explain these techniques with real protocols later.</source>
        <target state="translated">The size of the sliding window can be either fixed for a given protocol or negotiated during the connection establishment phase. Some protocols allow to change the maximum window size during the data transfer. We will explain these techniques with real protocols later.</target>
        <context-group name="" purpose="location">
          <context context-type="sourcefile">../../principles/reliability.rst</context>
          <context context-type="linenumber">1054</context>
        </context-group>
      </trans-unit>
    </body>
  </file>
</xliff>
