priqueue.cc

ns2.1b5版本中cbrp碼

/* -*- c++ -*-
   priqueue.cc
   
   A simple priority queue with a remove packet function
   $Id: priqueue.cc,v 1.17 1998/10/10 12:51:31 broch Exp $
   */

#include <object.h>
#include <queue.h>
#include <drop-tail.h>
#include <packet.h>
#include <cmu/cmu-trace.h>

#include "priqueue.h"

typedef int (*PacketFilter)(Packet *, void *);

PriQueue_List PriQueue::prhead = { 0 };

static class PriQueueClass : public TclClass {
public:
  PriQueueClass() : TclClass("Queue/DropTail/PriQueue") {}
  TclObject* create(int, const char*const*) {
    return (new PriQueue);
  }
} class_PriQueue;


PriQueue::PriQueue() : DropTail()
{
	logtarget_ = 0;	// no logging target by default
	ipaddr_ = 0;
        //added by Jinyang
        pq_end = NULL;
        bind("Prefer_Routing_Protocols", &Prefer_Routing_Protocols);
	LIST_INSERT_HEAD(&prhead, this, link);
}

int
PriQueue::command(int argc, const char*const* argv)
{
  if (argc == 2 && strcasecmp(argv[1], "reset") == 0)
    {
      Terminate();
      //FALL-THROUGH to give parents a chance to reset
    }
  else if(argc == 3)
    {
      if(strcmp(argv[1], "logtarget") == 0)
	{
	  logtarget_ = (Trace*) TclObject::lookup(argv[2]);
	  assert(logtarget_);
	  return (TCL_OK);
	}
      else if(strcmp(argv[1], "ipaddr") == 0)
	{
	  ipaddr_ = atoi(argv[2]);
	  return (TCL_OK);
	}
    }
  return DropTail::command(argc, argv);
}

void
PriQueue::recv(Packet *p, Handler *h)
{
        struct hdr_cmn *ch = HDR_CMN(p);

	if(logtarget_ && length() > 25) {
		sprintf(logtarget_->buffer(),
			"T %.9f _%d_ ifq len is %d",
			Scheduler::instance().clock(),
			ipaddr_, length());
		logtarget_->dump();
	}

        if(Prefer_Routing_Protocols) {

		if(DATA_PACKET(ch->ptype())) {
			Queue::recv(p, h);
		} else {
                        recvHighPriority(p, h);
			// must be a routing protocol packet...
                }
        }
        else {
                Queue::recv(p, h);
        }
}


void 
PriQueue::recvHighPriority(Packet *p, Handler *)
  // insert packet at front of queue
{
  /* Jinyang: we try not to re-order packets.  */
  q_->enqueHead(p);
/*
  if (pq_end) {
     p->next_ = pq_end->next_;
     pq_end->next_ = p;
     pq_end = p;
  }else {
     q_->enqueHead(p);
     pq_end = p;
  }  
*/
  if (q_->length() >= qlim_)
    {
      Packet *to_drop = q_->lookup(q_->length()-1);
      q_->remove(to_drop);
      drop(to_drop);
    }
  
  if (!blocked_) {
    /*
     * We're not blocked.  Get a packet and send it on.
     * We perform an extra check because the queue
     * might drop the packet even if it was
     * previously empty!  (e.g., RED can do this.)
     */
    p = deque();
    if (p != 0) {
      blocked_ = 1;
      target_->recv(p, &qh_);
    }
  } 
}
 
void 
PriQueue::filter(PacketFilter filter, void * data)
  // apply filter to each packet in queue, 
  // - if filter returns 0 leave packet in queue
  // - if filter returns 1 remove packet from queue
{
  int i = 0;
  while (i < q_->length())
    {
      Packet *p = q_->lookup(i);
      if (filter(p,data))
	{
	  q_->remove(p); // decrements q len
	}
      else i++;
    }
}

Packet*
PriQueue::filter(nsaddr_t id)
{
	Packet *p = 0;
	Packet *pp = 0;
	struct hdr_cmn *ch;

	for(p = q_->head(); p; p = p->next_) {
		ch = HDR_CMN(p);
		if(ch->next_hop() == id)
			break;
		pp = p;
	}

	/*
	 * Deque Packet
	 */
	if(p) {
		if(pp == 0)
			q_->remove(p);
		else
			q_->remove(p, pp);
	}
	return p;
}

/*
 * Called at the end of the simulation to purge the IFQ.
 */
void
PriQueue::Terminate()
{
	Packet *p;
	while((p = deque())) {
		drop(p, DROP_END_OF_SIMULATION);
	}
}