#include <sattrace.h>
Inheritance diagram for SatDequeTrace:


Public Member Functions | |
| SatDequeTrace (int type) | |
| void | recv (Packet *p, Handler *) |
| void | traceonly (Packet *p) |
| int | command (int argc, const char *const *argv) |
| virtual void | recv (Packet *p, const char *s) |
| void | recvOnly (Packet *p) |
| virtual void | write_nam_trace (const char *s) |
| void | trace (TracedVar *var) |
| NsObject * | target () |
| virtual void | drop (Packet *p) |
| virtual void | delay_bind_init_all () |
| virtual int | delay_bind_dispatch (const char *varName, const char *localName, TclObject *tracer) |
| int | isdebug () const |
| virtual void | debug (const char *fmt,...) |
Static Public Member Functions | |
| int | get_seqno (Packet *p) |
Public Attributes | |
| BaseTrace * | pt_ |
| int | type_ |
Protected Member Functions | |
| void | format (int tt, int s, int d, Packet *p) |
| void | annotate (const char *s) |
| void | callback () |
| virtual void | drop (Packet *p, const char *s) |
| void | send (Packet *p, Handler *h) |
| virtual void | reset () |
| void | handle (Event *) |
Protected Attributes | |
| nsaddr_t | src_ |
| nsaddr_t | dst_ |
| int | callback_ |
| int | show_tcphdr_ |
| NsObject * | target_ |
| NsObject * | drop_ |
| int | debug_ |
|
|
Definition at line 55 of file sattrace.h.
00055 : SatTrace(type) {} |
|
|
Definition at line 160 of file trace.cc. References BaseTrace::buffer(), Trace::callback(), Scheduler::clock(), BaseTrace::dump(), Scheduler::instance(), BaseTrace::namdump(), BaseTrace::nbuffer(), Trace::pt_, BaseTrace::round(), BaseTrace::tagged(), and TIME_FORMAT. Referenced by Trace::command().
00161 {
00162 if (pt_->tagged()) {
00163 sprintf(pt_->buffer(),
00164 "v "TIME_FORMAT" -e {sim_annotation %g %s}",
00165 Scheduler::instance().clock(),
00166 Scheduler::instance().clock(), s);
00167 } else {
00168 sprintf(pt_->buffer(),
00169 "v "TIME_FORMAT" eval {set sim_annotation {%s}}",
00170 pt_->round(Scheduler::instance().clock()), s);
00171 }
00172 pt_->dump();
00173 callback();
00174 sprintf(pt_->nbuffer(), "v -t "TIME_FORMAT" -e sim_annotation %g %s",
00175 Scheduler::instance().clock(),
00176 Scheduler::instance().clock(), s);
00177 pt_->namdump();
00178 }
|
Here is the call graph for this function:

|
|
Definition at line 401 of file trace.cc. References BaseTrace::buffer(), Trace::callback_, and Trace::pt_. Referenced by Trace::annotate(), DequeTrace::recv(), Trace::recv(), Trace::recvOnly(), and Trace::trace().
|
Here is the call graph for this function:

|
||||||||||||
|
Reimplemented from Connector. Reimplemented in CMUTrace. Definition at line 83 of file trace.cc. References Trace::annotate(), BaseTrace::channel(), Connector::command(), BaseTrace::flush(), BaseTrace::namchannel(), Trace::pt_, BaseTrace::tagged(), and Trace::write_nam_trace(). Referenced by CMUTrace::command().
00084 {
00085 Tcl& tcl = Tcl::instance();
00086 if (argc == 2) {
00087 if (strcmp(argv[1], "detach") == 0) {
00088 pt_->channel(0) ;
00089 pt_->namchannel(0) ;
00090 return (TCL_OK);
00091 }
00092 if (strcmp(argv[1], "flush") == 0) {
00093 Tcl_Channel ch = pt_->channel();
00094 Tcl_Channel namch = pt_->namchannel();
00095 if (ch != 0)
00096 pt_->flush(ch);
00097 //Tcl_Flush(pt_.channel());
00098 if (namch != 0)
00099 //Tcl_Flush(pt_->namchannel());
00100 pt_->flush(namch);
00101 return (TCL_OK);
00102 }
00103 if (strcmp(argv[1], "tagged") == 0) {
00104 tcl.resultf("%d", pt_->tagged());
00105 return (TCL_OK);
00106 }
00107 } else if (argc == 3) {
00108 if (strcmp(argv[1], "annotate") == 0) {
00109 if (pt_->channel() != 0)
00110 annotate(argv[2]);
00111 return (TCL_OK);
00112 }
00113 if (strcmp(argv[1], "attach") == 0) {
00114 int mode;
00115 const char* id = argv[2];
00116 Tcl_Channel ch = Tcl_GetChannel(tcl.interp(), (char*)id,
00117 &mode);
00118 pt_->channel(ch);
00119 if (pt_->channel() == 0) {
00120 tcl.resultf("trace: can't attach %s for writing", id);
00121 return (TCL_ERROR);
00122 }
00123 return (TCL_OK);
00124 }
00125 if (strcmp(argv[1], "namattach") == 0) {
00126 int mode;
00127 const char* id = argv[2];
00128 Tcl_Channel namch = Tcl_GetChannel(tcl.interp(),
00129 (char*)id, &mode);
00130 pt_->namchannel(namch);
00131 if (pt_->namchannel() == 0) {
00132 tcl.resultf("trace: can't attach %s for writing", id);
00133 return (TCL_ERROR);
00134 }
00135 return (TCL_OK);
00136 }
00137 if (strcmp(argv[1], "ntrace") == 0) {
00138 if (pt_->namchannel() != 0)
00139 write_nam_trace(argv[2]);
00140 return (TCL_OK);
00141 }
00142 if (strcmp(argv[1], "tagged") == 0) {
00143 int tag;
00144 if (Tcl_GetBoolean(tcl.interp(),
00145 (char*)argv[2], &tag) == TCL_OK) {
00146 pt_->tagged(tag);
00147 return (TCL_OK);
00148 } else return (TCL_ERROR);
00149 }
00150 }
00151 return (Connector::command(argc, argv));
00152 }
|
Here is the call graph for this function:

|
||||||||||||
|
Definition at line 102 of file object.cc. References NsObject::debug_.
00103 {
00104 if (!debug_)
00105 return;
00106 va_list ap;
00107 va_start(ap, fmt);
00108 vprintf(fmt, ap);
00109 }
|
|
||||||||||||||||
|
Reimplemented in BayFullTcpAgent, Agent, MPLSAddressClassifier, LDPAgent, FullTcpAgent, SackFullTcpAgent, RFC793eduTcpAgent, TcpSink, TcpAgent, and VegasTcpAgent. Definition at line 63 of file object.cc. References NsObject::debug_. Referenced by MPLSAddressClassifier::delay_bind_dispatch(), and Agent::delay_bind_dispatch().
00064 {
00065 if (delay_bind_bool(varName, localName, "debug_", &debug_, tracer))
00066 return TCL_OK;
00067 return TclObject::delay_bind_dispatch(varName, localName, tracer);
00068 }
|
|
|
Reimplemented in BayFullTcpAgent, Agent, MPLSAddressClassifier, LDPAgent, FullTcpAgent, SackFullTcpAgent, RFC793eduTcpAgent, TcpSink, TcpAgent, and VegasTcpAgent. Definition at line 57 of file object.cc. Referenced by MPLSAddressClassifier::delay_bind_init_all(), and Agent::delay_bind_init_all().
00058 {
00059 delay_bind_init_one("debug_");
00060 }
|
|
||||||||||||
|
Definition at line 114 of file connector.cc. References Connector::drop_, Packet::free(), and NsObject::recv().
00115 {
00116 if (drop_ != 0)
00117 drop_->recv(p, s);
00118 else
00119 Packet::free(p);
00120 }
|
Here is the call graph for this function:

|
Here is the call graph for this function:

|
||||||||||||||||||||
|
Reimplemented from Trace. Definition at line 72 of file sattrace.cc. References abort(), hdr_flags::access(), hdr_srm::access(), hdr_rtp::access(), hdr_tcp::access(), hdr_ip::access(), hdr_cmn::access(), hdr_tcp::ackno(), Node::address(), BaseTrace::buffer(), Scheduler::clock(), hdr_flags::cong_action_, SatPosition::coord(), hdr_ip::daddr(), hdr_ip::dport(), hdr_flags::ecn_, hdr_flags::ecn_capable_, hdr_flags::ecn_to_echo_, hdr_tcp::flags(), hdr_ip::flowid(), hdr_flags::fs_, SatGeometry::get_latitude(), SatGeometry::get_longitude(), hdr_tcp::hlen(), Scheduler::instance(), Address::instance(), hdr_cmn::last_hop_, BaseTrace::namchannel(), p_info::name(), BaseTrace::nbuffer(), hdr_cmn::next_hop_, Node::nextnode(), Node::nodehead_, NUMFLAGS, packet_info, packet_t, SatNode::position(), hdr_flags::pri_, Address::print_nodeaddr(), Address::print_portaddr(), Trace::pt_, PT_ACK, PT_CBR, PT_EXP, PT_FTP, PT_HTTP, PT_PARETO, PT_RTP, PT_TCP, PT_TELNET, PT_UDP, hdr_cmn::ptype(), RAD_TO_DEG, BaseTrace::round(), hdr_tcp::sa_length(), hdr_ip::saddr(), hdr_tcp::seqno(), hdr_rtp::seqno(), sh, Trace::show_tcphdr_, hdr_cmn::size(), hdr_ip::sport(), srm_names_, BaseTrace::tagged(), and hdr_cmn::uid(). Referenced by recv(), and SatTrace::traceonly().
00073 {
00074 hdr_cmn *th = hdr_cmn::access(p);
00075 hdr_ip *iph = hdr_ip::access(p);
00076 hdr_tcp *tcph = hdr_tcp::access(p);
00077 hdr_rtp *rh = hdr_rtp::access(p);
00078 hdr_srm *sh = hdr_srm::access(p);
00079
00080 const char* sname = "null";
00081 int lasth, nexth, snadd;
00082 Node* n;
00083
00084 packet_t t = th->ptype();
00085 const char* name = packet_info.name(t);
00086
00087 /* SRM-specific */
00088 if (strcmp(name,"SRM") == 0 || strcmp(name,"cbr") == 0 || strcmp(name,"udp") == 0) {
00089 if ( sh->type() < 5 && sh->type() > 0 ) {
00090 sname = srm_names_[sh->type()];
00091 }
00092 }
00093
00094 if (name == 0)
00095 abort();
00096
00097 int seqno;
00098 /* UDP's now have seqno's too */
00099 if (t == PT_RTP || t == PT_CBR || t == PT_UDP || t == PT_EXP ||
00100 t == PT_PARETO)
00101 seqno = rh->seqno();
00102 else if (t == PT_TCP || t == PT_ACK || t == PT_HTTP || t == PT_FTP ||
00103 t == PT_TELNET)
00104 seqno = tcph->seqno();
00105 else
00106 seqno = -1;
00107 /*
00108 * When new flags are added, make sure to change NUMFLAGS
00109 * in trace.h
00110 */
00111 char flags[NUMFLAGS+1];
00112 for (int i = 0; i < NUMFLAGS; i++)
00113 flags[i] = '-';
00114 flags[NUMFLAGS] = 0;
00115
00116 hdr_flags* hf = hdr_flags::access(p);
00117 flags[0] = hf->ecn_ ? 'C' : '-'; // Ecn Echo
00118 flags[1] = hf->pri_ ? 'P' : '-';
00119 flags[2] = '-';
00120 flags[3] = hf->cong_action_ ? 'A' : '-'; // Congestion Action
00121 flags[4] = hf->ecn_to_echo_ ? 'E' : '-'; // Congestion Experienced
00122 flags[5] = hf->fs_ ? 'F' : '-';
00123 flags[6] = hf->ecn_capable_ ? 'N' : '-';
00124
00125 #ifdef notdef
00126 flags[1] = (iph->flags() & PF_PRI) ? 'P' : '-';
00127 flags[2] = (iph->flags() & PF_USR1) ? '1' : '-';
00128 flags[3] = (iph->flags() & PF_USR2) ? '2' : '-';
00129 flags[5] = 0;
00130 #endif
00131 char *src_nodeaddr = Address::instance().print_nodeaddr(iph->saddr());
00132 char *src_portaddr = Address::instance().print_portaddr(iph->sport());
00133 char *dst_nodeaddr = Address::instance().print_nodeaddr(iph->daddr());
00134 char *dst_portaddr = Address::instance().print_portaddr(iph->dport());
00135
00136 // Find position of previous hop and next hop
00137 double s_lat = -999, s_lon = -999, d_lat = -999, d_lon = -999;
00138 n = Node::nodehead_.lh_first;
00139 // XXX what if n is not a SatNode?? Need a dynamic cast here, or make sure that
00140 // only sat tracing elements go between sat nodes.
00141 // SatNode *sn = dynamic_cast<SatNode*>(n);
00142 if (n) {
00143 lasth = th->last_hop_;
00144 nexth = th->next_hop_;
00145 for (; n; n = n->nextnode() ) {
00146 SatNode *sn = (SatNode*) n;
00147 snadd = sn->address();
00148 if (lasth == snadd) {
00149 s_lat = RAD_TO_DEG(SatGeometry::get_latitude(sn->position()->coord()));
00150 s_lon = RAD_TO_DEG(SatGeometry::get_longitude(sn->position()->coord()));
00151 if (d_lat != -999)
00152 break; // Have now found both s and d
00153 }
00154 if (nexth == snadd) {
00155 d_lat = RAD_TO_DEG(SatGeometry::get_latitude(sn->position()->coord()));
00156 d_lon = RAD_TO_DEG(SatGeometry::get_longitude(sn->position()->coord()));
00157 if (s_lat != -999)
00158 break; // Have now found both s and d
00159 }
00160 }
00161 }
00162
00163 if (pt_->tagged()) {
00164 sprintf(pt_->nbuffer(),
00165 "%c %g -s %d -d %d -p %s -e %d -c %d -i %d -a %d -x {%s.%s %s.%s %d %s %s}",
00166 tt,
00167 Scheduler::instance().clock(),
00168 s,
00169 d,
00170 name,
00171 th->size(),
00172 iph->flowid(),
00173 th->uid(),
00174 iph->flowid(),
00175 src_nodeaddr,
00176 src_portaddr,
00177 dst_nodeaddr,
00178 dst_portaddr,
00179 seqno,flags,sname);
00180 } else if (!show_tcphdr_) {
00181 sprintf(pt_->buffer(), "%c %.4f %d %d %s %d %s %d %s.%s %s.%s %d %d %.2f %.2f %.2f %.2f",
00182 tt,
00183 pt_->round(Scheduler::instance().clock()),
00184 lasth,
00185 nexth,
00186 name,
00187 th->size(),
00188 flags,
00189 iph->flowid() /* was p->class_ */,
00190 // iph->src() >> (Address::instance().NodeShift_[1]),
00191 // iph->src() & (Address::instance().PortMask_),
00192 // iph->dst() >> (Address::instance().NodeShift_[1]),
00193 // iph->dst() & (Address::instance().PortMask_),
00194 src_nodeaddr,
00195 src_portaddr,
00196 dst_nodeaddr,
00197 dst_portaddr,
00198 seqno,
00199 th->uid(), /* was p->uid_ */
00200 s_lat,
00201 s_lon,
00202 d_lat,
00203 d_lon);
00204 } else {
00205 sprintf(pt_->buffer(),
00206 "%c %.4f %d %d %s %d %s %d %s.%s %s.%s %d %d %d 0x%x %d %d %.2f %.2f %.2f %.2f",
00207 tt,
00208 pt_->round(Scheduler::instance().clock()),
00209 lasth,
00210 nexth,
00211 name,
00212 th->size(),
00213 flags,
00214 iph->flowid(), /* was p->class_ */
00215 // iph->src() >> (Address::instance().NodeShift_[1]),
00216 // iph->src() & (Address::instance().PortMask_),
00217 // iph->dst() >> (Address::instance().NodeShift_[1]),
00218 // iph->dst() & (Address::instance().PortMask_),
00219 src_nodeaddr,
00220 src_portaddr,
00221 dst_nodeaddr,
00222 dst_portaddr,
00223 seqno,
00224 th->uid(), /* was p->uid_ */
00225 tcph->ackno(),
00226 tcph->flags(),
00227 tcph->hlen(),
00228 tcph->sa_length(),
00229 s_lat,
00230 s_lon,
00231 d_lat,
00232 d_lon);
00233 }
00234 if (pt_->namchannel() != 0)
00235 sprintf(pt_->nbuffer(),
00236 "%c -t %g -s %d -d %d -p %s -e %d -c %d -i %d -a %d -x {%s.%s %s.%s %d %s %s}",
00237 tt,
00238 Scheduler::instance().clock(),
00239 s,
00240 d,
00241 name,
00242 th->size(),
00243 iph->flowid(),
00244 th->uid(),
00245 iph->flowid(),
00246 src_nodeaddr,
00247 src_portaddr,
00248 dst_nodeaddr,
00249 dst_portaddr,
00250 seqno,flags,sname);
00251 delete [] src_nodeaddr;
00252 delete [] src_portaddr;
00253 delete [] dst_nodeaddr;
00254 delete [] dst_portaddr;
00255 }
|
Here is the call graph for this function:

|
|
Definition at line 186 of file trace.cc. References hdr_tfrc::access(), hdr_rap::access(), hdr_rtp::access(), hdr_tcp::access(), hdr_cmn::access(), packet_t, PT_ACK, PT_CBR, PT_EXP, PT_FTP, PT_HTTP, PT_PARETO, PT_RAP_ACK, PT_RAP_DATA, PT_RTP, PT_TCP, PT_TELNET, PT_TFRC, PT_UDP, hdr_cmn::ptype(), hdr_tfrc::seqno, hdr_tcp::seqno(), hdr_rap::seqno(), and hdr_rtp::seqno(). Referenced by Trace::format().
00187 {
00188 hdr_cmn *th = hdr_cmn::access(p);
00189 hdr_tcp *tcph = hdr_tcp::access(p);
00190 hdr_rtp *rh = hdr_rtp::access(p);
00191 hdr_rap *raph = hdr_rap::access(p);
00192 hdr_tfrc *tfrch = hdr_tfrc::access(p);
00193 packet_t t = th->ptype();
00194 int seqno;
00195
00196 /* UDP's now have seqno's too */
00197 if (t == PT_RTP || t == PT_CBR || t == PT_UDP || t == PT_EXP ||
00198 t == PT_PARETO)
00199 seqno = rh->seqno();
00200 else if (t == PT_RAP_DATA || t == PT_RAP_ACK)
00201 seqno = raph->seqno();
00202 else if (t == PT_TCP || t == PT_ACK || t == PT_HTTP || t == PT_FTP ||
00203 t == PT_TELNET)
00204 seqno = tcph->seqno();
00205 else if (t == PT_TFRC)
00206 seqno = tfrch->seqno;
00207 else
00208 seqno = -1;
00209 return seqno;
00210 }
|
Here is the call graph for this function:

|
|
Implements Handler. Reimplemented in LinkDelay, LL, AckRecons, and Snoop. Definition at line 91 of file object.cc. References NsObject::recv().
|
Here is the call graph for this function:

|
|
Definition at line 61 of file object.h. References NsObject::debug_.
00061 { return debug_; }
|
|
||||||||||||
|
Reimplemented in CMUTrace. Definition at line 96 of file object.cc. References Packet::free().
00097 {
00098 Packet::free(p);
00099 }
|
Here is the call graph for this function:

|
||||||||||||
|
Reimplemented from Trace. Definition at line 280 of file sattrace.cc. References hdr_flags::access(), hdr_srm::access(), hdr_ip::access(), hdr_cmn::access(), Scheduler::clock(), hdr_flags::cong_action_, hdr_ip::daddr(), hdr_ip::dport(), Trace::dst_, BaseTrace::dump(), hdr_flags::ecn_, hdr_flags::ecn_capable_, hdr_flags::ecn_to_echo_, hdr_ip::flowid(), SatTrace::format(), Packet::free(), hdr_flags::fs_, Scheduler::instance(), Address::instance(), BaseTrace::namchannel(), BaseTrace::namdump(), p_info::name(), BaseTrace::nbuffer(), NUMFLAGS, packet_info, packet_t, hdr_flags::pri_, Address::print_nodeaddr(), Address::print_portaddr(), Trace::pt_, hdr_cmn::ptype(), hdr_ip::saddr(), Connector::send(), sh, hdr_cmn::size(), hdr_ip::sport(), Trace::src_, srm_names_, Connector::target_, Trace::type_, and hdr_cmn::uid().
00281 {
00282 // write the '-' event first
00283 format(type_, src_, dst_, p);
00284 pt_->dump();
00285 pt_->namdump();
00286
00287 if (pt_->namchannel() != 0) {
00288 hdr_cmn *th = hdr_cmn::access(p);
00289 hdr_ip *iph = hdr_ip::access(p);
00290 hdr_srm *sh = hdr_srm::access(p);
00291 const char* sname = "null";
00292
00293 packet_t t = th->ptype();
00294 const char* name = packet_info.name(t);
00295
00296 if (strcmp(name,"SRM") == 0 || strcmp(name,"cbr") == 0 || strcmp(name,"udp") == 0) {
00297 if ( sh->type() < 5 && sh->type() > 0 ) {
00298 sname = srm_names_[sh->type()];
00299 }
00300 }
00301
00302 char *src_nodeaddr = Address::instance().print_nodeaddr(iph->saddr());
00303 char *src_portaddr = Address::instance().print_portaddr(iph->sport());
00304 char *dst_nodeaddr = Address::instance().print_nodeaddr(iph->daddr());
00305 char *dst_portaddr = Address::instance().print_portaddr(iph->dport());
00306
00307 char flags[NUMFLAGS+1];
00308 for (int i = 0; i < NUMFLAGS; i++)
00309 flags[i] = '-';
00310 flags[NUMFLAGS] = 0;
00311
00312 hdr_flags* hf = hdr_flags::access(p);
00313 flags[0] = hf->ecn_ ? 'C' : '-'; // Ecn Echo
00314 flags[1] = hf->pri_ ? 'P' : '-';
00315 flags[2] = '-';
00316 flags[3] = hf->cong_action_ ? 'A' : '-'; // Congestion Action
00317 flags[4] = hf->ecn_to_echo_ ? 'E' : '-'; // Congestion Experienced
00318 flags[5] = hf->fs_ ? 'F' : '-';
00319 flags[6] = hf->ecn_capable_ ? 'N' : '-';
00320
00321 #ifdef notdef
00322 flags[1] = (iph->flags() & PF_PRI) ? 'P' : '-';
00323 flags[2] = (iph->flags() & PF_USR1) ? '1' : '-';
00324 flags[3] = (iph->flags() & PF_USR2) ? '2' : '-';
00325 flags[5] = 0;
00326 #endif
00327
00328 sprintf(pt_->nbuffer(),
00329 "%c -t %g -s %d -d %d -p %s -e %d -c %d -i %d -a %d -x {%s.%s %s.%s %d %s %s}",
00330 'h',
00331 Scheduler::instance().clock(),
00332 src_,
00333 dst_,
00334 name,
00335 th->size(),
00336 iph->flowid(),
00337 th->uid(),
00338 iph->flowid(),
00339 src_nodeaddr,
00340 src_portaddr,
00341 dst_nodeaddr,
00342 dst_portaddr,
00343 -1, flags, sname);
00344 pt_->namdump();
00345 delete [] src_nodeaddr;
00346 delete [] src_portaddr;
00347 delete [] dst_nodeaddr;
00348 delete [] dst_portaddr;
00349 }
00350
00351 /* hack: if trace object not attached to anything free packet */
00352 if (target_ == 0)
00353 Packet::free(p);
00354 else
00355 send(p, h);
00356 }
|
Here is the call graph for this function:

|
|
Reimplemented from NsObject. Definition at line 365 of file trace.cc. References Trace::callback(), Trace::dst_, BaseTrace::dump(), Trace::format(), BaseTrace::namdump(), Trace::pt_, NsObject::recvOnly(), Trace::src_, Connector::target_, and Trace::type_.
|
Here is the call graph for this function:

|
|
Reimplemented in BayFullTcpAgent, HashClassifier, IvsSource, dsREDQueue, DiffusionRate, SinkAgent, DiffusionAgent, FloodingAgent, OmniMcastAgent, LinkDelay, CBQueue, DropTail, ErrorModel, PIQueue, Queue< T >, RedPDQueue, REDQueue, REMQueue, RIOQueue, Snoop, FackTcpAgent, FullTcpAgent, SackFullTcpAgent, RFC793eduTcpAgent, Sack1TcpAgent, TcpSink, DelAckSink, TcpAgent, VegasTcpAgent, toraAgent, and Queue< T >. Definition at line 70 of file object.cc. Referenced by NsObject::command().
00071 {
00072 }
|
|
||||||||||||
|
Reimplemented in Agent, and LinkDelay. Definition at line 54 of file connector.h. References NsObject::recv(), and Connector::target_. Referenced by SessionTTLChecker::recv(), TTLChecker::recv(), DequeTrace::recv(), Trace::recv(), TraceIpMac::recv(), TraceIp::recv(), recv(), SALink::recv(), SnoopQueueEDrop::recv(), SnoopQueueTagger::recv(), SnoopQueueDrop::recv(), SnoopQueueOut::recv(), SnoopQueueIn::recv(), PktCounter::recv(), NetworkInterface::recv(), MeasureMod::recv(), Filter::recv(), Connector::recv(), CMUTrace::recv(), CBQClass::recv(), and AddSR::recv().
|
Here is the call graph for this function:

|
|
Definition at line 48 of file connector.h. References Connector::target_. Referenced by JoBS::assignRateDropsADC(), FQ::deque(), QSAgent::recv(), and MIPMHAgent::reg().
00048 { return target_; }
|
|
|
Definition at line 374 of file trace.cc. References BaseTrace::buffer(), Trace::callback(), Scheduler::clock(), BaseTrace::dump(), Scheduler::instance(), Trace::pt_, BaseTrace::round(), BaseTrace::tagged(), TIME_FORMAT, and Trace::type_.
00375 {
00376 char tmp[256] = "";
00377 Scheduler& s = Scheduler::instance();
00378 if (&s == 0)
00379 return;
00380
00381 if (pt_->tagged()) {
00382 sprintf(pt_->buffer(), "%c "TIME_FORMAT" -a %s -n %s -v %s",
00383 type_,
00384 pt_->round(s.clock()),
00385 var->owner()->name(),
00386 var->name(),
00387 var->value(tmp, 256));
00388 } else {
00389 // format: use Mark's nam feature code without the '-' prefix
00390 sprintf(pt_->buffer(), "%c t"TIME_FORMAT" a%s n%s v%s",
00391 type_,
00392 pt_->round(s.clock()),
00393 var->owner()->name(),
00394 var->name(),
00395 var->value(tmp, 256));
00396 }
00397 pt_->dump();
00398 callback();
00399 }
|
Here is the call graph for this function:

|
|
Definition at line 257 of file sattrace.cc. References Trace::dst_, BaseTrace::dump(), SatTrace::format(), Trace::pt_, Trace::src_, and Trace::type_. Referenced by UnslottedAlohaMac::backoff(), SatRouteAgent::forwardPacket(), and UnslottedAlohaMac::sendUp().
|
Here is the call graph for this function:

|
|
Definition at line 154 of file trace.cc. References BaseTrace::namdump(), BaseTrace::nbuffer(), and Trace::pt_. Referenced by Trace::command().
|
Here is the call graph for this function:

|
|
Definition at line 59 of file trace.h. Referenced by Trace::callback(), and Trace::Trace(). |
|
|
Reimplemented in FECModel, FloodAgent, and LandmarkAgent. Definition at line 66 of file object.h. Referenced by REDQueue::command(), RedPDQueue::command(), PushbackQueue::command(), NsObject::debug(), NsObject::delay_bind_dispatch(), RedPDQueue::enque(), PushbackQueue::enque(), NsObject::isdebug(), NsObject::NsObject(), TfrcAgent::recv(), PushbackQueue::reportDrop(), and REDQueue::reset(). |
|
|
Definition at line 57 of file connector.h. Referenced by Connector::command(), Connector::drop(), and ErrorModel::recv(). |
|
|
Definition at line 58 of file trace.h. Referenced by DequeTrace::recv(), Trace::recv(), recv(), Trace::recvOnly(), Trace::Trace(), and SatTrace::traceonly(). |
|
|
|
Definition at line 63 of file trace.h. Referenced by Trace::format(), SatTrace::format(), and Trace::Trace(). |
|
|
Definition at line 57 of file trace.h. Referenced by CMUTrace::format_mac(), CMUTrace::format_rtp(), CMUTrace::nam_format(), CMUTrace::node_energy(), DequeTrace::recv(), Trace::recv(), TraceIpMac::recv(), TraceIp::recv(), recv(), CMUTrace::recv(), Trace::recvOnly(), Trace::Trace(), and SatTrace::traceonly(). |
|
|
|
Definition at line 71 of file trace.h. Referenced by CMUTrace::CMUTrace(), CMUTrace::format_mac(), CMUTrace::nam_format(), DequeTrace::recv(), Trace::recv(), TraceIpMac::recv(), TraceIp::recv(), recv(), CMUTrace::recv(), Trace::recvOnly(), Trace::trace(), and SatTrace::traceonly(). |
1.3.3