void
TcpSrcPeriodic::doNextEvent() {
if (_idle_time==0||_active_time==0) {
_is_active = true;
startflow();
return;
}
if (_is_active) {
if (eventlist().now()>=_end_active && _idle_time!=0 && _active_time!=0 ) {
_is_active = false;
//this clears RTOs too
reset();
eventlist().sourceIsPendingRel(*this,(simtime_picosec)(2*drand()*_idle_time));
}
else if (_rtx_timeout_pending) {
TcpSrc::doNextEvent();
}
else {
cout << "Wrong place to be in: doNextDEvent 1" << eventlist().now() << " end active " << _end_active << "timeout " << _rtx_timeout_pending << endl;
//maybe i got a timeout here. How?
exit(1);
}
}
else {
_is_active = true;
((TcpSinkPeriodic*)_sink)->reset();
_start_active = eventlist().now();
_end_active = _start_active + (simtime_picosec)(2*drand()*_active_time);
eventlist().sourceIsPending(*this,_end_active);
startflow();
}
}
void
TcpRtxTimerScanner::doNextEvent()
{
simtime_picosec now = eventlist().now();
tcps_t::iterator i;
for (i = _tcps.begin(); i!=_tcps.end(); i++) {
(*i)->rtx_timer_hook(now);
}
eventlist().sourceIsPendingRel(*this, _scanPeriod);
}
void SinkLoggerSampling::doNextEvent(){
eventlist().sourceIsPendingRel(*this,_period);
simtime_picosec now = eventlist().now();
simtime_picosec delta = now - _last_time;
_last_time = now;
for (uint64_t i=0;i<_sinks.size();i++){
TcpAck::seq_t deltaB = _sinks[i]->_cumulative_ack - _last_seq[i];
double rate = deltaB * 1000000000000.0 / delta;//Bps
_last_seq[i] = _sinks[i]->_cumulative_ack;
_logfile->writeRecord(TcpLogger::TCP_SINK,_sinks[i]->id,TcpLogger::RATE,rate,0.0,0.0);
}
}
void
TcpSrc::retransmit_packet() {
TcpPacket* p = TcpPacket::newpkt(_flow, *_route, _last_acked+1, _mss);
p->flow().logTraffic(*p,*this,TrafficLogger::PKT_CREATESEND);
_last_sent_time = eventlist().now();
p->sendOn();
}
void
TcpSrc::connect(route_t& routeout, route_t& routeback, TcpSink& sink, simtime_picosec starttime)
{
_route = &routeout;
_sink = &sink;
_flow.id = id; // identify the packet flow with the TCP source that generated it
_sink->connect(*this, routeback);
eventlist().sourceIsPending(*this,starttime);
}
void
AggregateTcpLogger::doNextEvent() {
eventlist().sourceIsPending(*this,max(eventlist().now()+_period,_logfile->_starttime));
double totunacked=0;
double toteffcwnd=0;
double totcwnd=0;
int numflows=0;
for (tcplist_t::iterator i = _monitoredTcps.begin(); i!=_monitoredTcps.end(); i++) {
TcpSrc* tcp = *i;
uint32_t cwnd = tcp->_cwnd;
uint32_t unacked = tcp->_unacked;
uint32_t effcwnd = tcp->_effcwnd;
totcwnd += cwnd;
toteffcwnd += effcwnd;
totunacked += unacked;
numflows++;
}
_logfile->writeRecord(TcpLogger::TCP_RECORD,id,TcpLogger::AVE_CWND,totcwnd/numflows,totunacked/numflows,toteffcwnd/numflows);
}
void
TcpSrc::send_packets() {
while ( _last_acked + _cwnd >= _highest_sent + _mss) {
TcpPacket* p = TcpPacket::newpkt(_flow, *_route, _highest_sent+1, _mss);
p->flow().logTraffic(*p,*this,TrafficLogger::PKT_CREATESEND);
_highest_sent += _mss; //XX beware wrapping
_last_sent_time = eventlist().now();
p->sendOn();
}
}
void
QueueLoggerSampling::doNextEvent()
{
eventlist().sourceIsPendingRel(*this,_period);
if (_queue==NULL) return;
mem_b queuebuff = _queue->_maxsize;
if (!_seenQueueInD) { // queue size hasn't changed in the past D time units
_logfile->writeRecord(QUEUE_APPROX,_queue->id,QUEUE_RANGE,(double)_lastq,(double)_lastq,(double)_lastq);
_logfile->writeRecord(QUEUE_APPROX,_queue->id,QUEUE_OVERFLOW,0,0,(double)queuebuff);
}
else { // queue size has changed
_logfile->writeRecord(QUEUE_APPROX,_queue->id,QUEUE_RANGE,(double)_lastq,(double)_minQueueInD,(double)_maxQueueInD);
_logfile->writeRecord(QUEUE_APPROX,_queue->id,QUEUE_OVERFLOW,-(double)_lastIdledInD,(double)_lastDroppedInD,(double)queuebuff);
}
_seenQueueInD=false;
simtime_picosec now = eventlist().now();
simtime_picosec dt_ps = now-_lastlook;
_lastlook = now;
if ((_queue!=NULL) & (_queue->_queuesize==0)) _cumidle += timeAsSec(dt_ps); // if the queue is empty, we've just been idling
_logfile->writeRecord(QUEUE_RECORD,_queue->id,CUM_TRAFFIC,_cumarr,_cumidle,_cumdrop);
}
void
QueueLoggerSampling::logQueue(Queue& queue, QueueEvent ev, Packet &pkt) {
if (_queue==NULL) _queue=&queue;
assert(&queue==_queue);
_lastq = queue._queuesize;
if (!_seenQueueInD) {
_seenQueueInD=true;
_minQueueInD=queue._queuesize;
_maxQueueInD=_minQueueInD;
_lastDroppedInD=0;
_lastIdledInD=0;
_numIdledInD=0;
_numDropsInD=0;
}
else {
_minQueueInD=min(_minQueueInD,queue._queuesize);
_maxQueueInD=max(_maxQueueInD,queue._queuesize);
}
simtime_picosec now = eventlist().now();
simtime_picosec dt_ps = now-_lastlook;
double dt = timeAsSec(dt_ps);
_lastlook = now;
switch(ev) {
case PKT_SERVICE: // we've just been working
break;
case PKT_ENQUEUE:
_cumarr += timeAsSec(queue.drainTime(&pkt));
if (queue._queuesize>pkt.size()) // we've just been working
{}
else { // we've just been idling
mem_b idledwork = queue.serviceCapacity(dt_ps);
_cumidle += dt;
_lastIdledInD = idledwork;
_numIdledInD++;
}
break;
case PKT_DROP: // assume we've just been working
assert(queue._queuesize>=pkt.size()); // it is possible to drop when queue is idling, but this logger can't make sense of it
double localdroptime = timeAsSec(queue.drainTime(&pkt));
_cumarr += localdroptime;
_cumdrop += localdroptime;
_lastDroppedInD = pkt.size();
_numDropsInD++;
break;
}
}
