wrp.pc

无线网络仿真工具Glomosim2.03

   printLTable(node);
#endif

#ifndef DEBUGOUTPUT
    #ifdef SHOWTABLES
        printDTable(node);
        printRTable(node);
        printLTable(node);
    #endif
#endif

    if (node->appData.routingStats == TRUE)
    {
        WrpPrintRoutingStats(node);
    }

}

static void WrpInitStats(GlomoNode *nodePtr)
{
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)nodePtr->appData.routingVar;


    /* Total number of RT packets sent */
    wrp->stats.numRTsent = 0;

    /* Total number of packets received from Transport Layer. */
    wrp->stats.numFromTransport = 0;

}

int packPayload(GlomoNode *node)
{
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;
    void *bptr;
    char buf[MAX_NW_PAYLOAD_SIZE];
    int psize;

    psize = 0;
    memset(buf, 0, sizeof(char)*MAX_NW_PAYLOAD_SIZE);
    
    bptr = (void *)buf;
    memcpy(bptr,(void *)wrp->responseList, sizeof(int)*node->numNodes);
    memcpy(bptr,(void *)wrp->responseList, sizeof(int)*node->numNodes);
    bptr = (void *) ((int) bptr + sizeof(int)*node->numNodes);
    psize += sizeof(int) * node->numNodes;
    memcpy(bptr,(void *)wrp->LIST, sizeof(WrpTuple)*wrp->LISTct);
    bptr = (void *) ((int) bptr + (sizeof(WrpTuple)*wrp->LISTct));
    psize += sizeof(WrpTuple) * wrp->LISTct;

    memcpy(wrp->wpkt->payload, buf, psize);
    wrp->wpkt->hdr.packetSize = psize;
    wrp->wpkt->hdr.msgType = WRP_RT;
    wrp->wpkt->hdr.k = node->nodeAddr;
    wrp->wpkt->hdr.valid = wrp->LISTct;
    wrp->wpkt->hdr.seqNum = wrp->SEQNO;
    wrp->wpkt->hdr.timestamp = simclock();

    return psize+sizeof(WrpPacketHeader);
}

void unpackPayload(GlomoNode *node)
{
    void *bptr;
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;
    int count;

    bptr = (void *)wrp->wpkt->payload;
    memcpy(wrp->responseList, bptr, sizeof(int)*node->numNodes);
    wrp->ACKthis = wrp->responseList[node->nodeAddr];
    bptr = (void *) ((int) bptr + sizeof(int)*node->numNodes);
    memcpy(wrp->V, bptr, sizeof(WrpTuple)*wrp->wpkt->hdr.valid);
    wrp->Vct = wrp->wpkt->hdr.valid;
    bptr = (void *) ((int) bptr + sizeof(WrpTuple)*wrp->wpkt->hdr.valid);

#ifdef DEBUG
    for (count=0; count < wrp->Vct; count++)
        printf("(%d,%d,%d,%d)\n",wrp->V[count].u, wrp->V[count].j,
               wrp->V[count].RDkj, wrp->V[count].rpkj);
#endif

}

int NewNeighbor(GlomoNode *node, int k)
{
    int count;
    int X = 1;
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;

    if (wrp->Ni[k]==0) /* not even a neighbor */
        X = 0;
    for (count=0; count<node->numNodes; count++)
        if ((count!=k)&&(wrp->DTable[count].dat[k].dist<WRP_INFINITY))
            X = 0;
    return X;
}

int MinEntry(GlomoNode *node, NODE_ADDR dest)
{
    int b,
        MinVal = WRP_INFINITY,
        MinInd = -1;
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;

    for (b=0; b < node->numNodes; b++)
      if ((b!=node->nodeAddr) && (wrp->Ni[b]==1))
         if ( wrp->DTable[dest].dat[b].dist <= MinVal )
         {
            MinVal = wrp->DTable[dest].dat[b].dist;
            MinInd = b;
         }
#ifdef DEBUG
   printf("#%u: Min Dist from %u-%u is %d thru %d\n",
          node->nodeAddr,node->nodeAddr,dest,MinVal,MinInd);
#endif
   return MinInd;
}

void setTimer(GlomoNode *node,int type, int k, clocktype delay)
{
    WrpTimer *wt;
    Message *newMsg;
/*
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;
*/

    newMsg =  GLOMO_MsgAlloc(node,
                             GLOMO_APP_LAYER,
                             APP_ROUTING_WRP,
                             MSG_APP_TimerExpired);

    GLOMO_MsgInfoAlloc(node, newMsg, sizeof(WrpTimer));
    wt = (WrpTimer *) GLOMO_MsgReturnInfo(newMsg);

    wt->timerType = type;
    wt->k = k;
    
    GLOMO_MsgSend(node, newMsg, delay);
/*
    GLOMO_SendMsg(node,GLOMO_NETWORK_LAYER, MSG_NETWORK_CheckTimeoutAlarm,
                  &wt, sizeof(WrpTimer), delay);
*/


}

void Init1(GlomoNode *node)
{
    clocktype delay;
    int count;
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;
    
    wrp->wpkt->hdr.seqNum = 0;
    wrp->SEQNO = 0;
    /* set a link state table with costs of adjacent links
     * Julian: assume none known at startup
     * N <- i ; Ni <- x | l(i)x < INFINITY
     */
    wrp->N[node->nodeAddr] = 1;
    
    /* for each x in Ni:
     *     Ni <- Ni U x ; tag(i)x <- null ;
     *     s(i)x <- null ; p(i)x <- null ; D(i)x <- INFINITY 
     */

    /* D(i)i <- 0 ; s(i)i <- null ; p(i)i <- null ; 
     * tag(i)i <- correct */
    wrp->RTable[node->nodeAddr].dest = node->nodeAddr;
    wrp->RTable[node->nodeAddr].dist = 0;
    wrp->RTable[node->nodeAddr].succ = -1;
    wrp->RTable[node->nodeAddr].pred = -1;
    wrp->RTable[node->nodeAddr].tag = 1;
    
    /* for each J in N, call Init2(x,j)
     */

    /* for each n in Ni, do add (0,i,0,i) to LISTi(n)
     */

    /* Julian: this will perform the initial HELLO msg */
    wrp->LIST[0].u = 0;
    wrp->LIST[0].j = node->nodeAddr;
    wrp->LIST[0].RDkj = 0;
    wrp->LIST[0].rpkj = node->nodeAddr;
    wrp->LISTct = 1;
    memset(wrp->responseList, 0, sizeof(int)*node->numNodes);
    delay = (clocktype) 100 * MILLI_SECOND;
    delay *= pc_erand(node->seed);

    broadcastUpdateMsg(node,ANY_DEST,(clocktype) delay);

    setTimer(node,WRP_INIT_TIMER,0,(clocktype) WRP_HELO_TIME);

    /* x <- retx time ; y <- max hello count ; z >- max retx count
     */
    for (count=0; count<node->numNodes; count++) {
        wrp->LTable[count].x = WRP_RETX_TIME;
        wrp->LTable[count].y = WRP_MAX_HELLO; 
        wrp->LTable[count].z = WRP_MAX_RETX;
    }

    /* Julian: start retransmission timer */
/* OLD
    setTimer(node,WRP_RETX_TIMER,0,(clocktype)WRP_RETX_TIME);
*/
    delay = (clocktype) WRP_RETX_TIME;
    delay *= pc_erand(node->seed);
    setTimer(node,WRP_RETX_TIMER,0,(clocktype)delay);

    /* Julian: start transmission timer */
    delay = (clocktype) WRP_XMIT_TIME;
    delay *= pc_erand(node->seed);

    setTimer(node,WRP_XMIT_TIMER,0,(clocktype) delay);

}

void Init2(GlomoNode *node, NODE_ADDR x, NODE_ADDR j)
{
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;

    /* D(i)jx <- INF ; p(i)jx <- null ; s(i)jx <- null ; seqno(i)jx <- 0
     */
    wrp->DTable[j].dest = j;
    wrp->DTable[j].dat[x].via = x;
    wrp->DTable[j].dat[x].dist = WRP_INFINITY;
    wrp->DTable[j].dat[x].pred = -1;
}

void Messge(GlomoNode *node, NODE_ADDR k, int cost)
{
    /* when router i receives a message on link (i,k)
     */

    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;
    int x,
        i,
        j,
        ULct = 0,
        ALct = 0,
        count,
        count2;
    clocktype delay;
    WrpTuple *UpdList,
              *AckList;
    WrpTuple W;
    int *response = pc_malloc(sizeof(int)*node->numNodes);
    char clockStr[GLOMO_MAX_STRING_LENGTH];
    NODE_ADDR destId = k;

/* OLD 
    UpdList = pc_malloc(sizeof(WrpTuple)*node->numNodes);
    AckList = pc_malloc(sizeof(WrpTuple)*node->numNodes);
*/
/* 6/30/99 */
    UpdList = pc_malloc(sizeof(WrpTuple)*wrp->LISTmax);
    AckList = pc_malloc(sizeof(WrpTuple)*wrp->LISTmax);
/***********/


    if ((!UpdList) || (!AckList) || (!response)) {
        printf("WRP: Not enough memory.\n");
        assert(FALSE);
    }
    memset(UpdList, 0, sizeof(WrpTuple)*node->numNodes);
    memset(AckList, 0, sizeof(WrpTuple)*node->numNodes);

    if (wrp->Ni[destId]==0)
    {
        /* Julian: initialize seqno here
         */
        wrp->LTable[destId].seqno = 0;

#ifdef DEBUG
        printf("#%d: %d not in Ni\n",node->nodeAddr,k);
#endif
        /* Ni <- Ni U k
         */
        wrp->Ni[destId] = 1;

        /* Julian: Start HelloTimer rolling  
         */
        delay = (clocktype) WRP_XMIT_TIME;
        delay *= pc_erand(node->seed);

        setTimer(node,WRP_HELO_TIMER,k,(clocktype)(WRP_HELO_TIME+delay));

        /* l(i)k <- cost of new link
         */
        wrp->LTable[destId].dest = k;
        wrp->LTable[destId].dist = cost;

        /* Julian: for each j in N, call Init2(k,j)
         */
        for (j=0; j<node->numNodes; j++)
            if (wrp->N[j]==1)
                Init2(node,destId,j);

        /* Julian: since it is a neighbor, set the distance table
         *     entry through itself, to itself, to the link cost
         */
        wrp->DTable[destId].dat[destId].dist = cost;
        wrp->DTable[destId].dat[destId].pred = node->nodeAddr;

        /* Julian: broadcast link up
         */
        W.u = 0;
        W.j = k;
        W.RDkj = cost;
        W.rpkj = node->nodeAddr;

        for (count=0; count<node->numNodes; count++)
           if (wrp->Ni[count]==1)
               response[count] = 1;
           else
               response[count] = 0;
        response[k] = 0;
        addTuple(node,W,response);

        /* if k !in N, do
         */
        if (wrp->N[k]==0) {
            /* N <- N U k ; tag(i)k <- null
             */
            wrp->N[k] = 1;
            wrp->RTable[k].tag = 0;

#ifdef DEBUG
            printf("#%d: %d not in N either\n",node->nodeAddr,k);
#endif
            /* D(i)k <- INF ; p(i)k <- null ; s(i)k <- null
             */
            wrp->RTable[k].dest = k;
            wrp->RTable[k].dist = WRP_INFINITY;
            wrp->RTable[k].pred = -1;
            wrp->RTable[k].succ = -1;

            /* for each x in Ni, call Init2(x,k)
             */
            for (x=0; x<node->numNodes; x++)
                if ((wrp->Ni[x]==1)&&(x!=k))
                    Init2(node,x,k);
        }
#ifdef DEBUG
        printf("FLASH UP THE RTABLE\n");
#endif
        for (count=0; count<node->numNodes; count++)
        {
            if ((wrp->N[count]==1)&&(count!=node->nodeAddr)) {
                W.u = 0;
                W.j = count;
                W.RDkj = wrp->RTable[count].dist;
                W.rpkj = wrp->RTable[count].pred;
                for (i=0; i<node->numNodes; i++)
                    if (wrp->Ni[i]==1)
                        response[i] = 1;
                    else
                        response[i] = 0;

                addTuple(node,W,response);
            }
        }
    }
    /* Reset HelloTimer
     */
    delay = (clocktype) WRP_XMIT_TIME;
    delay *= pc_erand(node->seed);

    wrp->LTable[k].HelloTimer = simclock() + WRP_HELO_TIME + delay;
    wrp->LTable[k].HelloCount = 0;

    
    /* for each entry (u(k)j,j,RD(k)j,rp(k)j | i != j do 
     */
    for (count=0; count < wrp->Vct; count++)
    {
/*
        printf("    (%d,%d,%d,%d)\n",wrp->V[count].u,
               wrp->V[count].j, wrp->V[count].RDkj,
               wrp->V[count].rpkj);
*/

        if ((node->nodeAddr != wrp->V[count].j)&&
            (wrp->V[count].u==WRP_UPDATE)) {
            ctoa(simclock(),clockStr);
#ifdef DEBUG
            printf("#%d: (%d,%d,%d,%d) from %d at %s\n",node->nodeAddr,
                wrp->V[count].u, wrp->V[count].j, wrp->V[count].RDkj,
                wrp->V[count].rpkj, k,clockStr);
#endif

            /* if j !in N 
             */
            if (wrp->N[wrp->V[count].j]==0) {
                /* if RD(k)j = INF then delete entry 
                 */
                if (wrp->V[count].RDkj>=WRP_INFINITY) {
                    for (count2=count; count2<(wrp->Vct-1); count2++) {
#ifdef DEBUG
                        printf("#%d: Discarding entry\n",node->nodeAddr);
#endif
                        wrp->V[count2].u = wrp->V[count2+1].u;
                        wrp->V[count2].j = wrp->V[count2+1].j;
                        wrp->V[count2].RDkj = wrp->V[count2+1].RDkj;
                        wrp->V[count2].rpkj = wrp->V[count2+1].rpkj;
                    }
                    wrp->Vct--;
                }
                else {
#ifdef DEBUG
                    printf("#%d: Entry adds new node %d\n",node->nodeAddr,
                        wrp->V[count].j);
#endif
                    /* N <- N U j
                     */
                    wrp->N[wrp->V[count].j] = 1;
                    
                    /* Julian: tag(i)j <- null 
                     */
                    wrp->RTable[wrp->V[count].j].tag = 0;
                   
                    /* Julian: D(i)j <- INF ; p(i)j <- null ; s(i)j <- null
                     */
                    wrp->RTable[wrp->V[count].j].dest = wrp->V[count].j;
                    wrp->RTable[wrp->V[count].j].dist = WRP_INFINITY;
                    wrp->RTable[wrp->V[count].j].pred = -1;
                    wrp->RTable[wrp->V[count].j].succ = -1;

                    /* for each entry x in Ni, call Init2(x,j)
                     */
                    for (x=0; x<node->numNodes; x++)
                        if ((wrp->Ni[x]==1)&&(x!=wrp->V[count].j))