Private:psim

This page documents the development of a discrete event simulator for P2P video streaming applications. This simulator captures important features of data-driven video streaming systems. In particular, it is designed to evaluate: (i) the performance of various segment scheduling algorithms; (ii) the potential of network coding in multi-layer P2P video streaming systems.

Class Diagrams

• use long for time/offset in msec, which has a rollover time 24.85 days

class Layer { // video layer, we divide each layer into fixed size blocks, we keep track of
                    // block size and no blocks here
    int layer; // layer number it belongs to, set to zero for nonscalable frame
    int blockSize; // blocks are fixed size, in bytes
    int noBlocks; // how many block here
    int dataSize; // aggregate size of all blocks
}

class Frame { // video frame, read from trace file
    int no; // serial number
    long deadlineOffset; // deadline offset compared to the start of the video, in msec
    int totalSize; // total frame size in bytes, including all layers
    Hashtable<Integer, Layer> layers; // reference to layers of this frame, key is the layer id
}

class Segment { // packetized frames
    int no; // serial number
    Vector<Frame> frames; // reference to included frame
    int totalSize; // aggregate size in bytes
}

class Video { // a media file, shared by a group of peers
    String filename; // video trace file path and name
    Hashtable<int, Frame> frameTrace; // frames read from the trace file
    Hashtable<int, Segment> segmentTrace; // segments generated by the prepareSegments(...)
    void prepareSegments(int noFrame); // packetize frames into segment, 
        // noFrame indicates how many frames should we put in one segment; 
        // we might implement other packtization schemes later.
}

class Neighbor { // keep track of what my neighbor has done
    Peer peer; // peer instance, for accessing availability info
    int estimateRate; // estimated rate (maybe historical)
}

class Peer { // represent a running peer
    int ingressBW; // incoming bandwidth in bps
    int egressBW; // outgoing bandwidth in bps
    BitSet avail; // availability bufmap
    Vector<Neighbor> neighbors; // peers that we may send requests to 
    BufferedMatrix matrix; // matrix of coefficients and encoded values up to now
    NoEncodedBlocks noCodedBl; // keep track of No. of encoded blocks in each segment
}

class Group { // peers that have downloaded or want to download a Video
    Video video; // media shared among peers
    Vector<Peer> peers; // peers in this group
    void join(Peer peer); // adding a new peer into this group
    void leave(Peer peer); // removing a peer from this group
}

class Connection { // end to end network link between two peers
    Peer peer1; // one end
    Peer peer2; // the other
    long delay; // transmission delay in msec
    int e2eBW; // end-to-end bandwidth in bps
}

class BufferMap { // segment availability
    Vector<BitSet> segAvail; // segment availability for each layer of stream
}

class AdvertisedBuffermap { // show whether this segment is capable of serving other peers(applicable in NC)
    Vector<BitSet> servCapibility; // Serving capability of each segment
}

class BufferedMatrix{ // save coefficients and their corresponding encoded blocks up to now
    Vector<Vector> coef; // coefficients of the corresponding encoded blocks
    Vector <int>encodedValue; //encoded blocks
}

class NoEncodedBlocks{ // keep track of No. of encoded blocks in each segment
    Vector<Vector<int>> noCodedBl; // growable 2 dimensional array corresponding to segments and layers
                                                      // each element in this vector keep the No. of encoded blocks in the   
                                                      // corresponding segment
}
// XXX TODO XXX


class SimException {

}

Interface EventHandler {
    void handle() throws SimException; // callback function
}

class Event {
    long time; // when this event happens
    Peer src; // which peer generates this event
    Peer dst; // whom is destinate of this event 
    Vector<EventHandler> handlers; //process an event and update states accordingly
    int type; // enum, see below
    // 1. connect: peer 1 makes a connection to peer 2, and add each other into neighbors
    // 2. requestSent: a receiver sends a high-priority request message to a sender
    // 3. requestArrived: a request message gets to a sender
    // 4. dataSent: a sender sends a data segment
    // 5. dataArrived: a data segment arrives to a receiver

    void addHandler(Interface EventHandler); // add an additional event handler
    void rmvHandler(Interface EventHandler); // remove an additional event handler
}

class EventQueue {
    SortedMap<Long, Event> queue; // events sorted on its time
    void dispatch(Event event); // sequentially invoke even handlers 
}

class Simulator {
    long simTime; // elapsed simulation time in msec
    EventQueue events; // pending events that will be processed
    void dispatchEvent(); // forever loop to process the next event
}



Some comments:
  1. At the beginning, we should have a peer publish a video (or a trace file).
  2. The join() and leave() methods in the Group class may be moved to the Peer class and each peer
    should has a bitmap field.
  3. We may add a Tracker class:
    Class Tracker
    { 
      URL url; //peers use this url to find the tracker
      Vector<Peer> peers;         //maintain a peer list to be quired by peers
      Vector<InetAddress> SelectPeers();  //when a peer joins a group at the first time, it quires other peers from the
                                                                  //tracker,  then the tracker invokes SelectPeers() and returns
                                                                 //a list of neighbors to that peer
      void recordPeer(); //record information of a peer when it first connects the tracker or update it when some old
                                    //information is already stored
                                   //the information exchanged between a tracker and a peer may be <peerID, videoName>
                                   // or <peerID, videoName, ip_Address, port> if we want to do simulation on different machines
    } 
  4. If we really want to send video files between peers, we may need a Storage class to operate with files
  5. We may design a superclass of all peers, trackers, and neighbors, as a typical networking server to deal with
    network connections
  6. In case of Network Coding when a peer joins a group it will receive segments that are 'n' seconds after the current   
    playback point. ('n' is a tunable parameter)