rlc.tex

用C++编写的GPRS协议栈源代码

\section{Radio Link  Control (RLC)}

A new layer called  Radio Link Control is added to the wireless node,
between the LL and IFQ\footnotemark[2]. This required changes in {\it ~ns}/tcl/lib/ns-mobilenode.tcl

\footnotetext[2] { This was implemented by  Sandeep Kumar, Kopparapu
Suman and Richa Jain at Indian Institute of Technology, Bombay. June
2001}

 The main features included are fragmentation and assembly, along with RLC
retransmissions. The retransmit mechanism is a simplified form of Selective
Retransmits. The fragmentation-reassembly and acknowledgements may be
configured ON or OFF by the user and the RLC fragment size can be set. A new
header, the RLC header is introduced.
 Though this was written as a part of GPRS stack implementation, it can be
used independently with any other stack with minor modifications.

In case an RLC fragment is dropped by the MAC, in acknowledged mode, a
duplicate acknowledgment for the last correctly received RLC fragment is
sent
back to the sender, which then retransmits the expected RLC fragment.
In unacknowledged mode, if an RLC fragment is missing, the RLC does not
pass  any of the fragments to the LL. The LL in this case, would re-send the
LL  fragment (if in acknowledged mode) or will let the higher layers (ie
TCP) handle it.
In acked mode, currently only one MS can be supported.                  

In GPRS. the actual size of an RLC  packet's payload depends on the coding
scheme used. We take the average GPRS RLC  payload size to be 200 bytes. In
GPRS these 200 bytes are transmitted over four slots in  consecutive TDMA
frames,
amounting to 50 bytes per slot. To model this, the RLC fragments  are
configured to be of 50 bytes and thus 50 bytes are transmitted in each TDMA
slot.

\subsection {RLC  class in C++}

The RLC class derives from the LinkDelay class.  The code can be found in
{\it ~ns}/ll-timers.\{cc,h\} and {\it ~ns}/ll.\{cc,h\}. The functions and variables of the
class are shown below

\begin{verbatim}
class RLC : public LinkDelay {
     friend class rlcTxTimer;           //rtx timer for data pkts
     friend class rlcackTimer;          //rtx timer for rlc acks
public:
      :
     //new funcs
     virtual void recvACK(Packet* p);    //recv ack pkts
     virtual void recvDATA(Packet* p);   //recv data pkts
     virtual void sendUpDATA(Packet* p); //reassemble and send data up
     virtual void enqueDATA(Packet* p);  //frag and enque data
     virtual void sendDownDATA(void);    //send data down
     virtual void sendACK(Packet* p);    //send rlc ack
      :
     virtual void RetransmitDATA(void);  //rtx data on timeout
     virtual void RetransmitACK(void);   //rtx rlc on timeout
     virtual void sendDownDATAonACK(void);  //send data when recv ack
      :
	  
protected:
     int command(int argc, const char*const* argv);
     static int rlcverbose_;  
     int seqno_;              // rlc sequence number
     int ackno_;              // ACK received so far
     int rackno_;             // seq no of left most pkt
     int macDA_;              // destination MAC address
     int window_;             //window size for sack
     Queue* ifq_;             // interface queue
     PacketQueue* buf_;       // queue to store frag pkts to sendDown
     PacketQueue* Txbuf_;     // Tx buffer
     PacketQueue* Rxbuf_;     // Rx buffer
       :
	 int acked_;              //RLC layer acked?
     int rlcfraged_;          //RLC layer PDU fragmented?
     int rlcfragsz_;          //RLC layer frag size
     int datacounter;         //no of rtx for data
     int ackcounter;          //no of rtx for rlc ack
     Packet *pktTx_;          //store rtx data
     Packet *pktRx_;          //store rtx  rlc ack
     int inseq_;              //flag for pkts in seq in unack mode
     int unackseqno_;         //seqno when in unack mode
     int numdups;             //no of dupacks for sack
      :	
}
\end{verbatim}

\subsection{Parameters}

    The following parameters can be set and the default values are set
in {\it ~ns}/tcl/lib/ns-default.tcl

\begin{verbatim}
RLC set mindelay_    50us
RLC set delay_       25us
RLC set bandwidth_   0    ;# not used
RLC set debug_       false

RLC set macDA_       0
RLC set acked_       1    ;# if 1 acked..0  non-acked
RLC set rlcfraged_   1    ;# if 1-frag.....0-nofrag
RLC set rlcfragsz_   45   ;# rlc frag size
RLC set rlcverbose_  0    ;# if 1 print debug info
\end{verbatim}

The debug info is written into stderr.

\subsection {Modifications for use outside GPRS}

To use this acked/fragmented RLC  for a non-GPRS mac layer, in the function
{\em sendACK()} in {\it ~ns}/rlc.cc ,  change the variable "dh" according to the mac layer
being used

\begin{verbatim}
      void RLC::sendACK(Packet* p)
        {
                ...
            hdr_mac_gprs *dh = HDR_MAC_GPRS(p);
                ...
        }
\end{verbatim}

For example, to use with  mac802\_11,  replace the shown line with:

         hdr\_mac802\_11 *dh =HDR\_MAC802\_11(p);


\subsection {To bypass the RLC}

RLC layer can be bypassed by changing the following part in
{\it ~ns}/tcl/lib/ns-mobilenode.tcl

\begin{verbatim}
     # Link Layer
     $ll arptable $arptable_
     $ll ifq $ifq
     $ll mac $mac
     # $ll down-target $ifq;    #if NO rlc uncomment it
     $ll down-target $rlc;      #if NO rlc comment this and rest of rlc below

     # for rlc
     $rlc up-target $ll
     $rlc mac $mac
     $rlc down-target $ifq
\end{verbatim}