Forward Error Correction

1
Forward Error Correction

• Final presentation
• Designed by Yoav Moratt
• Eyal Skulsky

2
Motivation

• Multi-cast the ability to send data over the
  internet to a large number of users, sets extreme
  challenges in the field of protocol.
• The model for this project is a server that sends
  a large amount of data to many users that are not
  synchronized with each other. This simulates the
  common situations in the real world like internet
  video streams (T.V., movies and lectures), large
  databases transfer etc.

3
Motivation

• Assume one server needs to send 100 datagrams to
  100 clients. Loss rate is 10 and clients start
  at the same time (for simplicity). This example
  will help us understand the difficulties and the
  challenges.

4
Motivation

• In this case, each client will lose 10 datagrams,
• The server has to resend them all to the clients,
  since most likely they did not all lose the same
  packets, the server will have to send all the 100
  packets of information again !

5
Motivation

• The Forward Error Correction solves all these
  problems and also solves other problems that
  originate from general server-clients relations.
• The Idea is to add redundancy to the data, in
  order to allow the client to restore lost
  packets. Due to the redundancy the client may
  lose a few packets and still be able to
  reconstruct the data from the other packets!

6
Motivation

• Example
• Assume loss rate of 1/9, for every 8 packets, the
  server sends a ninth packet with the XOR of the
  former 8 packets. Every client gets 8 packets
  (lost one). If it got the first 8, it uses them,
  else the missing packet is a simple XOR between
  all the rest.
• This means that the server sent only 10 more
  information to achieve the goal !!

7
Motivation

• Forward Error Correction Advantages
• Network efficiency we will show that traffic is
  sharply reduced when using FEC, even though
  redundant packets are being sent by the server.
• Client efficiency we will show that the average
  time the client awaits the completion of the
  transaction is by far shorter than the average
  waiting time when using the traditional
  protocols.
• Scalability the efficiency of the protocol is
  not affected by the number of clients in the
  group.
• Distribution the protocol does not require any
  synchronization between clients and server or
  between each other.

8
Project Goal

• In this project, the goal is to create a reliable
  simulation for FEC protocol that will bring all
  the above advantages to test. We will try to
  prove that this protocol is indeed the beginning
  of a new Era in the field of multicast.

9
General Configuration

In order to simplify the workspace and to gain
control of loss rate parameter, we decided that
all the clients will reside on the same machine
as the server and loss rate will be simulated by
discarding packets randomly. The project will be
run over the java virtual machine, (Operating
system invariant).
10
Configuration (cont.)

• Files are commonly too large to be sent in one,
  or even twenty, packets. With this in mind, we
  decided to split the file into segments
  (designated in our code as chunks), where each
  segment is an FEC entity in its own merit. Each
  segment was then divided into k packets, and then
  encoded into n packets, each of which also
  contains redundant information.

11
Configuration (cont.)

• This proposed segmentation of the file presents a
  new kind of problem, unsolved by the FEC
  protocol now the server still has to decide
  which segment it is to send each time a
  transmission cycle ends.

12
Configuration (cont.)

• But segments are significantly larger than
  packets, and so are inherently easier to handle.
  We argued, then, that at the segment level,
  rather than at the packet level, the traditional
  protocols (with modifications) would be
  sufficiently effective. Although either of the
  traditional protocols would have been suitable,
  we opted to implement the NACK protocol, mainly
  because it entails a lower cost of data transfer
  from server to clients.

13
Configuration (cont.)

• In our implementation, a link was set between
  each client and the server, to be used by each
  client to relay its requests for segments from
  the server. The server records all requests onto
  a map.
• The server sends only segments that are required
  (using the map to know which are required) and as
  soon as a segment has been transmitted, it
  deletes its entry from the map. This saves
  considerable time, since retransmission of
  segments that have been successfully received by
  the clients is avoided.

14
The project consists 6 major modules

• Server Application
• FEC encoder
• Client Application
• FEC decoder
• Network simulator
• Result analyzer
• Test Generator

15
General Structure
Test generator
Server Application
Client Application
Client Application
Client Application
Client Application
FEC encoder
FEC decoder
FEC decoder
Noisy Network Simulator
FEC decoder
FEC decoder
16
Server Application

• This module is divided to several Threads
• Listening threads
• One thread for awaiting new clients
• Thread for each client, to process requests
• Main thread
• Sends data according to the request map generated
  by the listening threads.

17
Client Application

• This module is also multi threaded
• Request thread
• This thread is connected to the server via TCP,
  it wakes up every now and then, checks if any use
  full data has arrived and if not, it launches a
  request to the server.
• Main thread
• Process data packets from the server and store
  the for Decoding.

18
FEC encoder/decoder
This module handles the FEC encoding/decoding
19
Network simulation

• This module simulates a noisy network by
  discarding packets randomly, according to the
  simulated loss rate. It is implemented with in
  the Client application

20
Result analyzer

• This module holds a set of functions that allow
  storing the data in a file using comma separated
  format for later analysis.
• It is implemented in the client App.

21
Test Generator

• This module is the user interface for generating
  tests easily.

22
Additions

• As a by product of our application, we also have
  the ability to launch a server and clients stand
  alone ( no generator ).
• We also added a GUI for the client which can be
  turned on by using the flag isDisplayOn in the
  Client.java file