mac-multihop.cc

Go to the documentation of this file.

/* -*-  Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
/*
 * Copyright (c) 1997 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *  This product includes software developed by the Daedalus Research
 *  Group at the University of California Berkeley.
 * 4. Neither the name of the University nor of the research group may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#ifndef lint
static const char rcsid[] =
    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/mac/mac-multihop.cc,v 1.14 2000/11/02 22:46:37 johnh Exp $ (UCB)";
#endif

#include "template.h"
#include "channel.h"
#include "mac-multihop.h"

/* 
 * For debugging.
 */
void dump_iphdr(hdr_ip *iph) 
{
        printf("\tsrc = %d, ", iph->saddr());
        printf("\tdst = %d\n", iph->daddr());
}       

static class MultihopMacClass : public TclClass {
public:
    MultihopMacClass() : TclClass("Mac/Multihop") {}
    TclObject* create(int, const char*const*) {
        return (new MultihopMac);
    }
} class_mac_multihop;

MultihopMac::MultihopMac() : mode_(MAC_IDLE), peer_(0),
    pendingPollEvent_(0), pkt_(0),
    ph_(this), pah_(this), pnh_(this), pth_(this), bh_(this)
{
    /* Bind a bunch of variables to access from Tcl */
    bind_time("tx_rx_", &tx_rx_);
    bind_time("rx_tx_", &rx_tx_);
    bind_time("rx_rx_", &rx_rx_);
    bind_time("backoffBase_", &backoffBase_);
    backoffTime_ = backoffBase_;
}

/*
 * Returns 1 iff the specified MAC is in the prescribed state, AND all
 * the other MACs are IDLE.
 */
int MultihopMac::checkInterfaces(int state) 
{
    MultihopMac *p;
    
    if (!(mode_ & state))
        return 0;
    else if (macList_ == 0)
        return 1;
    for (p = (MultihopMac *)macList_; p != this && p != NULL; 
         p = (MultihopMac *)(p->macList())) {
        if (p->mode() != MAC_IDLE) {
            return 0;
        }
    }
    return 1;
}

/*
 * Poll a peer node prior to a send.  There can be at most one POLL 
 * outstanding from a node at any point in time.  This is achieved implicitly
 * because there can be at most one packet down from LL (thru IFQ) to this MAC.
 */
void MultihopMac::poll(Packet *p)
{
    Scheduler& s = Scheduler::instance();
    MultihopMac *pm = (MultihopMac*) getPeerMac(p);
    PollEvent *pe = new PollEvent(pm, this);

    pendingPollEvent_ = new PollEvent(pm, this);
    pkt_ = p->copy();   /* local copy for poll retries */
    double timeout = max(pm->rx_tx(), tx_rx_) + 4*pollTxtime(MAC_POLLSIZE);
    s.schedule(&bh_, pendingPollEvent_, timeout);

    /*  If the other interfaces are idle, then go ahead, else not. */
    if (checkInterfaces(MAC_IDLE)) { 
        mode_ = MAC_POLLING;
        peer_ = pm;
        s.schedule(pm->ph(), (Event *)pe, pollTxtime(MAC_POLLSIZE));
    }
}

/*
 * Handle a POLL request from a peer node's MAC.
 */
void
PollHandler::handle(Event *e)
{
    PollEvent *pe = (PollEvent *) e;
    Scheduler& s = Scheduler::instance();
    MultihopMac* pm = mac_->peer(); /* sensible val only in MAC_RCV mode */
    
    /*
     * Send POLLACK if either IDLE or currently receiving 
     * from same mac as the poller.
     */
    if (mac_->checkInterfaces(MAC_IDLE)) { // all interfaces must be IDLE
        mac_->mode(MAC_RCV);
        pm = pe->peerMac();
        mac_->peer(pm);
        PollEvent *pae = new PollEvent(pm, mac_); // POLLACK event
        double t = mac_->pollTxtime(MAC_POLLACKSIZE) + 
            max(mac_->tx_rx(), pm->rx_tx());
        s.schedule(pm->pah(), pae, t);
    } else {
        // printf("ignoring poll %d\n", mac_->label());
        // could send NACKPOLL but don't (at least for now)
    }
}

/*
 * Handle a POLLACK from a peer node's MAC.
 */
void
PollAckHandler::handle(Event *e)
{
    PollEvent *pe = (PollEvent *) e;
    Scheduler& s = Scheduler::instance();

    if (mac_->checkInterfaces(MAC_POLLING | MAC_IDLE)) {
        mac_->backoffTime(mac_->backoffBase());
        mac_->mode(MAC_SND);
        mac_->peer(pe->peerMac());
        s.cancel(mac_->pendingPE()); /* cancel pending timeout */
        free(mac_->pendingPE());  // and free the event
        mac_->pendingPE(NULL);
        mac_->send(mac_->pkt()); /* send saved packet */
    }
}

void
PollNackHandler::handle(Event *)
{
}

void
BackoffHandler::handle(Event *)
{
    Scheduler& s = Scheduler::instance();
    if (mac_->mode() == MAC_POLLING) 
        mac_->mode(MAC_IDLE);
    double bTime = mac_->backoffTime(2*mac_->backoffTime());
    bTime = (1+Random::integer(MAC_TICK)*1./MAC_TICK)*bTime + 
        2*mac_->backoffBase();

//  printf("backing off %d\n", mac_->label());
    s.schedule(mac_->pth(), mac_->pendingPE(), bTime);
}

void 
PollTimeoutHandler::handle(Event *)
{
    mac_->poll(mac_->pkt());
}


/*
 * Actually send the data frame.
 */
void MultihopMac::send(Packet *p)
{
    Scheduler& s = Scheduler::instance();
    if (mode_ != MAC_SND)
        return;

    double txt = txtime(p);
    hdr_mac::access(p)->txtime() = txt;
    channel_->send(p, txt); // target is peer's mac handler
    s.schedule(callback_, &intr_, txt); // callback to higher layer (LL)
    mode_ = MAC_IDLE;
}

/*
 * This is the call from the higher layer of the protocol stack (i.e., LL)
 */
void MultihopMac::recv(Packet* p, Handler *h)
{
    if (h == 0) {       /* from MAC classifier (pass pkt to LL) */
        mode_ = MAC_IDLE;
        Scheduler::instance().schedule(target_, p, delay_);
        return;
    }
    callback_ = h;
    hdr_mac* mh = hdr_mac::access(p);
    mh->macSA() = addr_;
    if (mh->ftype() == MF_ACK) {
        mode_ = MAC_SND;
        send(p);
    } else {
        mh->ftype() = MF_DATA;
        poll(p);        /* poll first */
    }
}

---