1 / 39

CPS 114: Introduction to Computer Networks Lecture 4: Reliable Transmission

CPS 114: Introduction to Computer Networks Lecture 4: Reliable Transmission. Xiaowei Yang xwy@cs.duke.edu. Overview. Link layer functions Encoding Framing Error detection Reliable transmission. Clock-based Framing. STS-1/OC-1 frame 51.840Mbps The slowest SONET link.

rea
Download Presentation

CPS 114: Introduction to Computer Networks Lecture 4: Reliable Transmission

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. CPS 114: Introduction to Computer NetworksLecture 4: Reliable Transmission Xiaowei Yang xwy@cs.duke.edu

  2. Overview • Link layer functions • Encoding • Framing • Error detection • Reliable transmission

  3. Clock-based Framing • STS-1/OC-1 frame • 51.840Mbps • The slowest SONET link • Synchronous Optical Network (SONET) • A complex protocol • Each frame is 125 us long, 810bytes = 125 us * 51.84Mbps • 9 rows of 90 bytes each • First 3 bytes are overhead • First two bytes of each frame has a special pattern marking the start of a frame • When the special pattern turns up in the right place enough times (every 810B), a receive concludes it’s in sync.

  4. Synchronized timeslots as placeholder • Real frame data may float inside

  5. Overview • Link layer functions • Encoding • Framing • Error detection • Reliable transmission

  6. Error detection • Error detection code adds redundant information to detect errors • Analogy: sending two copies of the same message • Parity • Checksum • CRC • Error correcting code: more sophisticated code that can correct errors

  7. Two-dimensional parity • Even parity bit • Make an even number of 1s in each row and column • Detect all 1,2,3-bit errors, and most 4-bit errors A sample frame of six bytes

  8. Internet checksum algorithm • Basic idea • Add all the words transmitted and then send the sum. • Receiver does the same computation and compares the sums • IP checksum • Adding 16-bit short integers using 1’s complement arithmetic • Take 1’s complement of the result

  9. 1’s complement • -x is each bit of x inverted • If there is a carry bit, add 1 to the sum • Example: 4-bit integer • -3: 1100 (invert of 0011) • -4: 1011 (invert of 0100) • -3 + -4 = 0111 + 1 = 1000 (invert of 0111 (-7))

  10. IP checksum implementation (used in labs) • uint16_t cksum (const void *_data, intlen) {const uint8_t *data = _data; uint32_t sum; for (sum = 0;len >= 2; data += 2, len -= 2)   sum += data[0] << 8 | data[1]; if (len > 0)   sum += data[0] << 8; while (sum > 0xffff)   sum = (sum >> 16) + (sum & 0xffff); sum = htons (~sum); return sum ? sum : 0xffff;}

  11. Remarks • Can detect 1 bit error • But not all two-bits • One increases the sum, and one decreases it • Efficient for software implementation • Needs to be done for every packet inside a router!

  12. Cyclic Redundancy Check A branch of finite fields High-level idea: Represent an n+1-bit message with an n degree polynomial M(x) Divide the polynomial by a k-bit divisor C(x) k-bit CRC: remainder after divided by a degree-k divisor polynomial Send Message + CRC that is dividable by C(x)

  13. Polynomial arithmetic modulo 2 • B(x) can be divided by C(x) if B(x) has higher degree • B(x) can be divided once by C(x) if of same degree • Remainder of B(x)/C(x) = B(x) – C(x) • Substraction is done by XOR each pair of matching coefficients

  14. CRC algorithm • Multiply M(x) by x^k. Add k zeros to Message. Call it T(x) • Divide T(x) by C(x) and find the remainder • Send P(x) = T(x) – remainder • Append remainder to T(x) • P(x) dividable by C(x)

  15. An example 8-bit msg 10011010 Divisor (3bit CRC) 1101

  16. How to choose a divisor Complicated Intuition: unlikely to be divided evenly by an error Find C(x) by looking it up in a book

  17. Hardware implementation Very efficient: XOR operations 0 to k-1 registers (k-bit shift registers) If nth (n < k) term is not zero, places an XOR gate x3 + x2 + 1

  18. Overview • Link layer functions • Encoding • Framing • Error detection • Reliable transmission

  19. Reliable transmission • What to do if a receiver detects bit errors? • Two high-level approaches • Forward error correction (FEC): the correction of errors handled in advance by sending • Retransmission (lab 1) • Acknowledgements: a small piece of control information sent back to its peer acknowledging the receipt of a frame • Can be “piggybacked” on data packets • Timeouts: if a sender does not receive an ack after some time, retransmit the original frame • Also called Automatic repeat request (ARQ)

  20. Stop-and-wait • Send one frame, wait for an ack, and send the next • Retransmit if times out • Note in the last figure (d), there might be confusion: a new frame, or a duplicate?

  21. Sequence number • Add a sequence number to each frame to avoid the ambiguity

  22. Stop-and-wait drawback • Revisiting bandwidth-delay product • Total delay/latency = transmission delay + propagation delay + queuing • Queuing is the time packet sent waiting at a router’s buffer • Will revisit later (no sweat if you don’t get it now)

  23. Delay * bandwidth product For a 1Mbps pipe, it takes 8 seconds to transmit 1MB. If the link latency is less than 8 seconds, the pipe is full before all data are pumped into the pipe For a 1Gbps pipe, it takes 8 ms to transmit 1MB.

  24. Stop-and-wait drawback • A 1Mbps link with a 100ms two-way delay (round trip time, RTT) • 1KB frame size • Throughput = 1KB/ (1KB/1Mbps + 100ms) = 74Kbps << 1Mbps • Delay x bandwidth = 100Kb • So we could send ~12 frames before the pipe is full! • Throughput = 100Kb/(1KB/1Mbps + 100ms) = 926Kbps

  25. Sliding window • Key idea: allowing multiple outstanding (unacked) frames to keep the pipe full

  26. Sliding window on sender • Assign a sequence number (SeqNum) to each frame • Maintains three variables • Send window size (SWS) that bounds the number of unacked frames the sender can transmit • Last ack received (LAR) that denotes the sequence number of the last ACK received • Last frame sent (LFS) that denotes the sequence number of the last frame sent • Invariant: LFS – LAR ≤ SWS

  27. Sender actions • When an ACK arrives, moves LAR to the right, opening the window to allow the sender to send more frames • If a frame times out before an ACK arrives, retransmit Slide window this way when an ACK arrives

  28. Sliding window on receiver • Maintains three window variables • Receive window size (RWS) that bounds the number of out-of-order frames it’s willing to receive • Largest acceptable frame (LAF) denotes the sequence number of that frame • Last frame received (LFR) denotes the sequence number of last frame received • Invariant • LAF – LFR ≤ RWS

  29. When a frame with SeqNum arrives • Discards it if out of window • Seq≤ LFR or Seq > LAF • If in window, decides what to ACK • Cumulativeack: a variable SeqNumToAck denotes the largest sequence number not acked but all frames with a sequence number smaller than it have been acked • AcksSeqNumToAck even if higher-numbered packets have been received • Sets LFR = SeqNumToAck, LAF = LFR + RWS • Updates SeqNumToAck

  30. Finite sequence numbers • Things may go wrong when SWS=RWS, SWS too large • Example • 3-bit sequence number, SWS=RWS=7 • Sender sends 0, …, 6; receiver acks, expects (7,0, …, 5), but all acks lost • Sender retransmits 0,…,6; receiver thinks they are new • SWS < (MaxSeqNum+1)/2 • Alternates between first half and second half of sequence number space as stop-and-wait alternates between 0 and 1

  31. Sliding window protocol (SWP) implementation typedef u_char SwpSeqno; typedef struct { SwpSeqno SeqNum; /* sequence number of this frame */ SwpSeqno AckNum; /* ack of received frame */ u_char Flags; /* up to 8 bits' worth of flags */ } SwpHdr; Your code will look very different!

  32. typedef struct { /* sender side state: */ SwpSeqno LAR; /* seqno of last ACK received */ SwpSeqno LFS; /* last frame sent */ Semaphore sendWindowNotFull; SwpHdr hdr; /* preinitialized header */ struct sendQ_slot { Event timeout; /* event associated with send-timeout */ Msg msg; } sendQ[SWS]; /* receiver side state: */ SwpSeqno NFE; /* seqno of next frame expected */ struct recvQ_slot { int received; /* is msg valid? */ Msg msg; } recvQ[RWS]; } SwpState;

  33. static int sendSWP(SwpState *state, Msg *frame) { struct sendQ_slot *slot; hbuf[HLEN]; /* wait for send window to open */ semWait(&state->sendWindowNotFull); state->hdr.SeqNum = ++state->LFS; slot = &state->sendQ[state->hdr.SeqNum % SWS]; store_swp_hdr(state->hdr, hbuf); msgAddHdr(frame, hbuf, HLEN); msgSaveCopy(&slot->msg, frame); slot->timeout = evSchedule(swpTimeout, slot, SWP_SEND_TIMEOUT); return sendLINK(frame); }

  34. static int deliverSWP(SwpState state, Msg *frame) { SwpHdr hdr; char *hbuf; hbuf = msgStripHdr(frame, HLEN); load_swp_hdr(&hdr, hbuf) if (hdr->Flags & FLAG_ACK_VALID) { /* received an acknowledgment---do SENDER side */ if (swpInWindow(hdr.AckNum, state->LAR + 1, state->LFS)) { do { struct sendQ_slot *slot; slot = &state->sendQ[++state->LAR % SWS]; evCancel(slot->timeout); msgDestroy(&slot->msg); semSignal(&state->sendWindowNotFull); } while (state->LAR != hdr.AckNum); } }

  35. if (hdr.Flags & FLAG_HAS_DATA) { struct recvQ_slot *slot; /* received data packet---do RECEIVER side */ slot = &state->recvQ[hdr.SeqNum % RWS]; if (!swpInWindow(hdr.SeqNum, state->NFE, state->NFE + RWS - 1)) { /* drop the message */ return SUCCESS; } msgSaveCopy(&slot->msg, frame); slot->received = TRUE; if (hdr.SeqNum == state->NFE) { Msg m; while (slot->received) { deliverHLP(&slot->msg); msgDestroy(&slot->msg); slot->received = FALSE; slot = &state->recvQ[++state->NFE % RWS]; } /* send ACK: */ prepare_ack(&m, state->NFE - 1); sendLINK(&m); msgDestroy(&m); }} return SUCCESS; }

  36. static bool swpInWindow(SwpSeqno seqno, SwpSeqno min, SwpSeqno max) { SwpSeqno pos, maxpos; pos = seqno - min; /* pos *should* be in range [0..MAX)*/ maxpos = max - min + 1; /* maxpos is in range [0..MAX]*/ return pos < maxpos; }

  37. Flow control with sliding window • Remark: perhaps the best-known algorithm in computer networking • Multiple functions • Reliable deliver frames over a link • In-order delivery to upper layer protocol • Flow control • Not to overun a slow slower • Congestion control (later) • Not to congest the network

  38. Other ACK mechanisms • NACK: negative acks for packets not received • unnecessary, as sender timeouts would catch this information • SACK: selective ACK the received frames • + No need to send duplicate packets • - more complicated to implement • Newer version of TCP has SACK

  39. Conclusion • A lot for today • CRC • Reliability • FEC • Stop-and-Wait • Sliding window

More Related