How to Add a New Protocol in NS2

1
How to Add a New Protocol in NS2

• Xu Leiming
• CSCW Lab. at CS Dept., Tsinghua Univ.
• mailtoxlming_at_csnet4.cs.tsinghua.edu.cn
• June 1, 2001

2
Outline

• Overview
• An Example ---- Ping
• Packet flow
• Node models
• Our research

3
Overview

• New packet header
• C code
• Tcl code
• Some necessary changes

4
Packet Header
5
Packet Header
6
New Packet Header

• Create new header structure
• Enable tracing support of new header
• Create static class for OTcl linkage (packet.h)
• Enable new header in Otcl (tcl/lib/ns-packet.tcl)

7
New Agent

• Decide position in class hierarchy Derive from
  a agent class
• Link with a OTcl class
• TclClass TclObject
• TclObjectbind()
• Otcl --gt c command() ltotcl commandgt,
  tcl.result()
• c --gt otcl tcl.eval(ltotcl actiongt)
• Some member functions int Agentcommand(int
  argc, const charconst argv) void
  Agentrecv(Packet pkt, Handler)

8
Overview

• New packet header
• C code
• Tcl code
• Some necessary changes

9
Ping.h
struct hdr_ping char ret double
send_time // Header access methods static int
offset_ // required by PacketHeaderManager inlin
e static hdr_ping access(const Packet p)
return (hdr_ping) p-gtaccess(offset_) c
lass PingAgent public Agent public PingAgent
() virtual int command(int argc, const
charconst argv) virtual void recv(Packet,
Handler)
10
Ping.cc
int hdr_pingoffset_ static class
PingHeaderClass public PacketHeaderClass
public PingHeaderClass() PacketHeaderClass("
PacketHeader/Ping", sizeof(hdr_ping))
bind_offset(hdr_pingoffset_)
class_pinghdr static class PingClass public
TclClass public PingClass()
TclClass("Agent/Ping") TclObject create(int,
const charconst) return (new
PingAgent()) class_ping
11
Ping.cc (cont.)
PingAgentPingAgent() Agent(PT_PING) bind("p
acketSize_", size_)
12
int PingAgentcommand(int argc, const
charconst argv) if (argc 2) if
(strcmp(argv1, "send") 0) // Create
a new packet Packet pkt allocpkt()
// Access the Ping header for the new packet
hdr_ping hdr hdr_pingaccess(pkt)
// Set the 'ret' field to 0, so the receiving
node knows // that it has to generate an
echo packet hdr-gtret 0 // Store
the current time in the 'send_time' field
hdr-gtsend_time Schedulerinstance().clock()
// Send the packet send(pkt, 0)
// return TCL_OK, so the calling function knows
that the // command has been processed
return (TCL_OK) // If the command
hasn't been processed by PingAgent()command,
// call the command() function for the base
class return (Agentcommand(argc, argv))
13
void PingAgentrecv(Packet pkt, Handler)
// Access the IP header for the received packet
hdr_ip hdrip hdr_ipaccess(pkt) // Access
the Ping header for the received packet
hdr_ping hdr hdr_pingaccess(pkt) // Is
the 'ret' field 0 (i.e. the receiving node is
being pinged)? if (hdr-gtret 0) // Send an
'echo'. First save the old packet's
send_time double stime hdr-gtsend_time //
Discard the packet Packetfree(pkt) // Create
a new packet Packet pktret allocpkt() //
Access the Ping header for the new
packet hdr_ping hdrret hdr_pingaccess(pktre
t) // Set the 'ret' field to 1, so the receiver
won't send another echo hdrret-gtret 1 // Set
the send_time field to the correct
value hdrret-gtsend_time stime // Send the
packet send(pktret, 0)
14
else // A packet was received. Use tcl.eval
to call the Tcl // interpreter with the ping
results. // Note In the Tcl code, a procedure
'Agent/Ping recv from rtt' // has to be
defined which allows the user to react to the
ping // result. char out100 // Prepare the
output to the Tcl interpreter. Calculate the
round // trip time sprintf(out, "s recv d
3.1f", name(), hdrip-gtsrc_.addr_ gtgt
Addressinstance().NodeShift_1,
(Schedulerinstance().clock()-hdr-gtsend_time)
1000) Tcl tcl Tclinstance() tcl.eval(out)
// Discard the packet Packetfree(pkt)
15
Ping.tcl
Define a 'recv' function for the class
'Agent/Ping' Agent/Ping instproc recv from rtt
self instvar node_ puts "node node_ id
received ping answer from \ from
with round-trip-time rtt ms." set ns new
Simulator set nf open out.nam w ns
namtrace-all nf Create three nodes set n0 ns
node set n1 ns node
16
Connect the nodes with one link ns duplex-link
n0 n1 1Mb 10ms DropTail Create two ping
agents and attach them to the nodes n0 and n1 set
p0 new Agent/Ping ns attach-agent n0 p0 set
p1 new Agent/Ping ns attach-agent n1
p1 Connect the two agents ns connect p0
p1 Schedule events ns at 0.2 "p0 send" ns
at 0.4 "p1 send" ns at 0.6 "p0 send" ns at
0.6 "p1 send" ns at 1.0 "finish" Run the
simulation ns run
17
Necessary changes

• packet.h

enum packet_t PT_TCP, PT_UDP,
...... // insert new packet types
here PT_TFRC, PT_TFRC_ACK, PT_PING,
// packet protocol ID for our ping-agent PT_NTYP
E // This MUST be the LAST one
18
Necessary changes (cont.)

• packet.h

class p_info public p_info()
name_PT_TCP "tcp" name_PT_UDP
"udp" ...........
name_PT_TFRC "tcpFriend" name_PT_TFRC_ACK
"tcpFriendCtl"
name_PT_PING"Ping" name_PT_NTYPE
"undefined" .....
19
Necessary changes (cont.)

• tcl/lib/ns-default.tcl Agent/Ping set
  packetSize_ 64
• tcl/lib/ns-packet.tcl foreach prot
  AODV ARP aSRM Ping
  add-packet-header prot

20
Necessary changes (cont.)

• Makefile sessionhelper.o delaymodel.o srm-ssm.o
  \ srm-topo.o \ ping.o \ (LIB_DIR)int.Vec.o
  (LIB_DIR)int.RVec.o \ (LIB_DIR)dmalloc_support.
  o \
• Recompile and run make depend make ns
  ping.tcl

21
Packet flow
22
Node Models -- Wireless Node
23
Node Models -- LAN
24
Our Research Wireless routing

• Manet Mobile Ad hoc Networks
• No fixed infrastructure
• Mobile nodes
• Multi-hop wireless network
• Every host act as a router
• Routing protocol in Manet AODV DSR DSDV
• Target applications battlefield, border
  patrol, disaster recovery

25
(No Transcript)
26
Our Research Wireless routing

• CMU Ad-Hockey
• realistic scenario builder
• visualizations of the simulation trace files
• Scenario
• 1500m 300m, 50 nodes
• propogation range 250m
• max speed 20m/s
• pause time 0 30 60 120 300 600 900

27
Our Research Wireless routing

• Traffic
• CBR 4pkt/s
• source number 10 20 30
• Simlation time 900s
• Analyze the trace file perl program
• Performance metric
• packet delivery rate
• end-end delay
• protocol overhead