2. cnp3-ebook
3. principles/reliability
4. Search

Filters

• Untranslated strings • state:empty
• Unfinished strings • state:<translated
• Translated strings • state:>=translated
• Strings marked for edit • state:needs-editing
• Strings with suggestions • has:suggestion
• Strings with variants • has:variant
• Strings with screenshots • has:screenshot
• Strings with labels • has:label
• Strings with context • has:context
• Unfinished strings without suggestions • state:<translated AND NOT has:suggestion
• Strings with comments • has:comment
• Strings with any failing checks • has:check
• Approved strings • state:approved
• Strings waiting for review • state:translated

state:empty

Position and priority

• Position and priority
• Position
• Priority
• Labels
• Source string
• Target string
• String age
• Last updated
• Number of words
• Number of comments
• Number of failing checks
• Key
• String location
• Component and priority

	Translation	Source string	Target string
	cnp3-ebook/principles/reliability — Czech	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.
	cnp3-ebook/principles/reliability — French	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.
	cnp3-ebook/principles/reliability — Czech	**1** **2** **3** **4**
	cnp3-ebook/principles/reliability — French	**1** **2** **3** **4**
	cnp3-ebook/principles/reliability — Czech	`DLE STX` **1** **2** **3** **4** `DLE ETX`
	cnp3-ebook/principles/reliability — French	`DLE STX` **1** **2** **3** **4** `DLE ETX`
	cnp3-ebook/principles/reliability — Czech	**1** **2** **3** **DLE** **STX** **4**
	cnp3-ebook/principles/reliability — French	**1** **2** **3** **DLE** **STX** **4**
	cnp3-ebook/principles/reliability — Czech	`DLE STX` **1** **2** **3** **DLE** `DLE` **STX** `4` `DLE ETX`
	cnp3-ebook/principles/reliability — French	`DLE STX` **1** **2** **3** **DLE** `DLE` **STX** `4` `DLE ETX`
	cnp3-ebook/principles/reliability — Czech	**DLE STX DLE ETX**
	cnp3-ebook/principles/reliability — French	**DLE STX DLE ETX**
	cnp3-ebook/principles/reliability — Czech	`DLE STX` **DLE** `DLE` **STX** **DLE** `DLE` ETX** `DLE ETX`
	cnp3-ebook/principles/reliability — French	`DLE STX` **DLE** `DLE` **STX** **DLE** `DLE` ETX** `DLE ETX`
	cnp3-ebook/principles/reliability — Czech	Recovering from transmission errors
	cnp3-ebook/principles/reliability — French	Recovering from transmission errors
	cnp3-ebook/principles/reliability — Czech	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.
	cnp3-ebook/principles/reliability — French	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.
	cnp3-ebook/principles/reliability — Czech	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 :
	cnp3-ebook/principles/reliability — French	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 :
	cnp3-ebook/principles/reliability — Czech	the interactions between the user and the datalink layer entity are represented by using the classical `DATA.req` and the `DATA.ind` primitives
	cnp3-ebook/principles/reliability — French	the interactions between the user and the datalink layer entity are represented by using the classical `DATA.req` and the `DATA.ind` primitives
	cnp3-ebook/principles/reliability — Czech	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`
	cnp3-ebook/principles/reliability — French	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`
	cnp3-ebook/principles/reliability — Czech	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 :
	cnp3-ebook/principles/reliability — French	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 :
	cnp3-ebook/principles/reliability — Czech	data frames carrying a SDU
	cnp3-ebook/principles/reliability — French	data frames carrying a SDU
	cnp3-ebook/principles/reliability — Czech	These two types of frames can be distinguished by dividing the frame in two parts :
	cnp3-ebook/principles/reliability — French	These two types of frames can be distinguished by dividing the frame in two parts :
	cnp3-ebook/principles/reliability — Czech	the `header` that contains one bit set to `0` in data frames and set to `1` in control frames
	cnp3-ebook/principles/reliability — French	the `header` that contains one bit set to `0` in data frames and set to `1` in control frames
	cnp3-ebook/principles/reliability — Czech	the payload that contains the SDU supplied by the application
	cnp3-ebook/principles/reliability — French	the payload that contains the SDU supplied by the application
	cnp3-ebook/principles/reliability — Czech	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.
	cnp3-ebook/principles/reliability — French	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.
	cnp3-ebook/principles/reliability — Czech	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.
	cnp3-ebook/principles/reliability — French	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.
	cnp3-ebook/principles/reliability — Czech	Services and protocols
	cnp3-ebook/principles/reliability — French	Services and protocols
	cnp3-ebook/principles/reliability — Czech	Reliable data transfer on top of an imperfect link
	cnp3-ebook/principles/reliability — French	Reliable data transfer on top of an imperfect link
	cnp3-ebook/principles/reliability — Czech	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 :
	cnp3-ebook/principles/reliability — French	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 :
	cnp3-ebook/principles/reliability — Czech	Frames can be corrupted by transmission errors
	cnp3-ebook/principles/reliability — French	Frames can be corrupted by transmission errors
	cnp3-ebook/principles/reliability — Czech	Frames can be lost or unexpected frames can appear
	cnp3-ebook/principles/reliability — French	Frames can be lost or unexpected frames can appear
	cnp3-ebook/principles/reliability — Czech	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 :
	cnp3-ebook/principles/reliability — French	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 :
	cnp3-ebook/principles/reliability — Czech	random isolated errors where the value of a single bit has been modified due to a transmission error
	cnp3-ebook/principles/reliability — French	random isolated errors where the value of a single bit has been modified due to a transmission error
	cnp3-ebook/principles/reliability — Czech	random burst errors where the values of `n` consecutive bits have been changed due to transmission errors
	cnp3-ebook/principles/reliability — French	random burst errors where the values of `n` consecutive bits have been changed due to transmission errors
	cnp3-ebook/principles/reliability — Czech	random bit creations and random bit removals where bits have been added or removed due to transmission errors
	cnp3-ebook/principles/reliability — French	random bit creations and random bit removals where bits have been added or removed due to transmission errors
	cnp3-ebook/principles/reliability — Czech	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.
	cnp3-ebook/principles/reliability — French	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.
	cnp3-ebook/principles/reliability — Czech	`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 :
	cnp3-ebook/principles/reliability — French	`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 :
	cnp3-ebook/principles/reliability — Czech	`1001` is encoded as `10010`
	cnp3-ebook/principles/reliability — French	`1001` is encoded as `10010`
	cnp3-ebook/principles/reliability — Czech	`1101` is encoded as `11011`
	cnp3-ebook/principles/reliability — French	`1101` is encoded as `11011`
	cnp3-ebook/principles/reliability — Czech	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.
	cnp3-ebook/principles/reliability — French	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.
	cnp3-ebook/principles/reliability — Czech	Some coding schemes allow the receiver to correct some transmission errors. For example, consider the coding scheme that encodes each source bit as follows :
	cnp3-ebook/principles/reliability — French	Some coding schemes allow the receiver to correct some transmission errors. For example, consider the coding scheme that encodes each source bit as follows :
	cnp3-ebook/principles/reliability — Czech	`1` is encoded as `111`
	cnp3-ebook/principles/reliability — French	`1` is encoded as `111`
	cnp3-ebook/principles/reliability — Czech	`0` is encoded as `000`
	cnp3-ebook/principles/reliability — French	`0` is encoded as `000`
	cnp3-ebook/principles/reliability — Czech	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.
	cnp3-ebook/principles/reliability — French	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.
	cnp3-ebook/principles/reliability — Czech	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.
	cnp3-ebook/principles/reliability — French	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.
	cnp3-ebook/principles/reliability — Czech	3 bits string
	cnp3-ebook/principles/reliability — French	3 bits string
	cnp3-ebook/principles/reliability — Czech	Odd parity
	cnp3-ebook/principles/reliability — French	Odd parity
	cnp3-ebook/principles/reliability — Czech	Even parity
	cnp3-ebook/principles/reliability — French	Even parity
	cnp3-ebook/principles/reliability — Czech	000
	cnp3-ebook/principles/reliability — French	000
	cnp3-ebook/principles/reliability — Czech	1
	cnp3-ebook/principles/reliability — French	1
	cnp3-ebook/principles/reliability — Czech	0
	cnp3-ebook/principles/reliability — Czech	001
	cnp3-ebook/principles/reliability — French	001
	cnp3-ebook/principles/reliability — Czech	010
	cnp3-ebook/principles/reliability — French	010
	cnp3-ebook/principles/reliability — Czech	100
	cnp3-ebook/principles/reliability — French	100
	cnp3-ebook/principles/reliability — Czech	111
	cnp3-ebook/principles/reliability — French	111
	cnp3-ebook/principles/reliability — Czech	110
	cnp3-ebook/principles/reliability — French	110
	cnp3-ebook/principles/reliability — Czech	101
	cnp3-ebook/principles/reliability — French	101
	cnp3-ebook/principles/reliability — Czech	011

• 2 / 3
  / 3