wrp.pc

无线网络仿真工具Glomosim2.03

        wrp->RTable[j].succ = -1;

        /* Update Network Forwarding Table */
        NetworkUpdateForwardingTable(
            node, j, DEFAULT_INTERFACE, NETWORK_UNREACHABLE);

    }
    pc_free(response);
}

void Connectivity(GlomoNode *node, int k)
{
    int count;
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;
    WrpTuple W;
    int *response = pc_malloc(sizeof(int)*node->numNodes);
    clocktype delay;
    int *ZeroList;

    assert(response);
#ifdef DEBUGOUTPUT
    printf("#%d: Connectivity(%d)\n",node->nodeAddr,k);
#endif

    /* HelloCount[k] <- HelloCount[k] + 1 */
    wrp->LTable[k].HelloCount++;

    /* if (HelloCount[k] < y) then reset HelloTimer */
    if (wrp->LTable[k].HelloCount < wrp->LTable[k].y)
    {
#ifdef DEBUG
        printf("#%d: Reset HelloTimer for %d\n",node->nodeAddr,k);
#endif
        wrp->LTable[k].HelloTimer = simclock() + WRP_HELO_TIME;

        W.u = 0;
        W.j = node->nodeAddr;
        W.RDkj = 0;
        W.rpkj = node->nodeAddr;
        memset(response, 0, sizeof(int)*node->numNodes);
  
        response[k]=1;

        addTuple(node,W,response);

        /* Julian: count this as a hello message */

        /* Julian: remove necessity to MRL retx this message 
#ifdef DEBUG
        printf("#%d: removing HELO message from MRL\n",node->nodeAddr);
#endif
        Delete_RList(node, (wrp->SEQNO+WRP_MAX_SEQ_NUM-1)%WRP_MAX_SEQ_NUM, 
                     k);
*/
        delay = (clocktype) WRP_XMIT_TIME;
        delay *= pc_erand(node->seed);

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

    }
    else
    {
#ifdef DEBUGOUTPUT
        printf("#%d: Remove link to %d after %dth try\n",node->nodeAddr,k,
           wrp->LTable[k].y);
#endif
        /* Ni <- Ni - k */
        wrp->Ni[k] = 0;

        /*l(i)k <- INF ; tag(i)k <- null */
        wrp->LTable[k].dist = WRP_INFINITY;
        wrp->RTable[k].tag = 0;

        /* delete column for k in distance table */
        for (count=0; count<node->numNodes; count++)
            Init2(node,k,count);

        /* Julian: need to remove entries in distance table
         * that loop thru self to node k 
         */
        for (count=0; count < node->numNodes; count++)
            if (wrp->DTable[k].dat[count].pred == node->nodeAddr)
         {
            wrp->DTable[k].dat[count].dist = WRP_INFINITY;
            wrp->DTable[k].dat[count].pred = -1;
         }

        /* Julian: need to broadcast link down to neighbors */
        W.u = 0;
        W.j = k;
        W.RDkj = WRP_INFINITY;
        W.rpkj = -1;
        for (count=0;count<node->numNodes;count++)
            if (wrp->Ni[count]==1)
                response[count]=1;
            else
                response[count]=0;

        addTuple(node,W,response);

        /* update routing table */
        RT_Update(node,k);
        for (count=0; count<node->nodeAddr;count++)
        {
            if ((count!=node->nodeAddr)&&(count!=k)&&
                (wrp->RTable[count].succ==k))
            {
#ifdef DEBUG
                printf("#%d: Link down to %d adjusts route to %d\n",
                    node->nodeAddr,k,count);
#endif
                wrp->RTable[count].tag = 0;
                RT_Update(node,count);
            }
        }


        ZeroList = pc_malloc(sizeof(int)*node->numNodes);
        if (!ZeroList) {
            printf("Not enough memory.\n");
            assert(FALSE);
        }
        memset(ZeroList, 0, sizeof(int)*node->numNodes);
        if (memcmp(ZeroList,wrp->Ni,sizeof(int)*node->numNodes) == 0) {
#ifdef DEBUG
            printf("No longer any neighbors, starting hello timer.\n");
#endif
            setTimer(node,WRP_INIT_TIMER,0,(clocktype) WRP_HELO_TIME);

        }
        pc_free(ZeroList);

    }
    pc_free(response);
}

void addTuple(GlomoNode *node, WrpTuple W, int* response)
{
    int i,
        done = 0;
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;

#ifdef DEBUG
    printf("AddTuple (%d,%d,%d,%d)\n",W.u,W.j,W.RDkj,W.rpkj);
#endif
    for (i=0; i<wrp->LISTct; i++)
    {
#ifdef DEBUG
        printf("    compare to (%d,%d,%d,%d)\n",wrp->LIST[i].u, 
            wrp->LIST[i].j, wrp->LIST[i].RDkj, wrp->LIST[i].rpkj);
#endif
        if ((wrp->LIST[i].u==W.u)&&(wrp->LIST[i].j==W.j)&&(W.u == 0))
        {
#ifdef DEBUG
            printf("    replace (%d,%d,%d,%d) with (%d,%d,%d,%d)\n",
                wrp->LIST[i].u, wrp->LIST[i].j, wrp->LIST[i].RDkj,
                wrp->LIST[i].rpkj, W.u, W.j, W.RDkj, W.rpkj);
#endif
            wrp->LIST[i].RDkj = W.RDkj;
            wrp->LIST[i].rpkj = W.rpkj;
            done = 1;
            i = wrp->LISTct;
        }
    }
    if (!done)
    {
#ifdef DEBUG
        printf("    add this as %dth entry\n",wrp->LISTct);
#endif
        i = wrp->LISTct;
        wrp->LIST[i].u = W.u;
        wrp->LIST[i].j = W.j;
        wrp->LIST[i].RDkj = W.RDkj;
        wrp->LIST[i].rpkj = W.rpkj;
        wrp->LISTct = wrp->LISTct + 1;
    }
    for (i=0; i<node->numNodes; i++)
        if (response[i]==1)
            wrp->responseList[i] = 1;
        else
            wrp->responseList[i] = 0;

    if (wrp->LISTct >= wrp->LISTmax)
    {
#ifdef DEBUG
        printf("FORCED bcast\n");
#endif
        broadcastUpdateMsg(node,ANY_DEST,0);
    }
}

void broadcastUpdateMsg(GlomoNode *node, NODE_ADDR dest, clocktype delay)
{
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;
    int seqNum = wrp->SEQNO;
    int i,
        packetSize;
    NODE_ADDR destId;
    char buf[80];

#ifdef DEBUGOUTPUT
    ctoa(simclock(),buf);
    printf("#%d: broadcastUpdateMsg() at %s\n",node->nodeAddr,buf);
    for (i=0; i < wrp->LISTct; i++)
        printf("    (%d,%d,%d,%d)\n",wrp->LIST[i].u, wrp->LIST[i].j,
            wrp->LIST[i].RDkj, wrp->LIST[i].rpkj);
#endif
    destId = dest;
    packetSize = packPayload(node);
    Clean_RList(node,seqNum);
    Create_RList(node,wrp->LISTct);

    AppUdpSendNewDataWithPriority(node, 
                                  APP_ROUTING_WRP, 
                                  ANY_DEST, 
                                  (char *) wrp->wpkt, 
                                  packetSize, 
                                  CONTROL, 
                                  0);

    if (node->appData.routingStats == TRUE)
    {
        wrp->stats.numRTsent++;
    }
    wrp->LISTct = 0;
 
}

void Clean_RList(GlomoNode *node, int seqno)
{
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;
    WrpMrlTuple *head,*temp;
    int count;

#ifdef DEBUG
    printf("#%d: Clean_RList(%d) with %d\n",node->nodeAddr,seqno,
        wrp->MRL[seqno].MRLsize);
#endif
    /* for all entries in RList
          delete RList[seqno] */

    if (wrp->MRL[seqno].MRLsize > 0)
    {
        pc_free(wrp->MRL[seqno].dat);
        pc_free(wrp->MRL[seqno].bitmap);
    }

    wrp->MRL[seqno].MRLsize = 0;
    wrp->MRL[seqno].retx_counter = WRP_MAX_RETX;
    wrp->MRL[seqno].retx_count = 0;

}

void Delete_RList(GlomoNode *node, int seqno, int k)
{
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;
    WrpMrlTuple *head,*temp;
    int count,
        okdelete = 1;

#ifdef DEBUG
    printf("#%d: Delete_RList(%d)\n",node->nodeAddr,seqno);
#endif
    if (wrp->MRL[seqno].MRLsize > 0)
    {
        wrp->MRL[seqno].bitmap[k] = 0;
        for (count = 0; count < node->numNodes; count++)
        {
            if ((count != node->nodeAddr)&&(wrp->Ni[count]==1))
            {
                if (wrp->MRL[seqno].bitmap[count]==1)
                {
#ifdef DEBUG
                     printf("#%d: Awaiting ACK from %d\n",node->nodeAddr,
                            count);
#endif
                     okdelete = 0;
                }
            }
        }
        if (okdelete == 1)
        {
#ifdef DEBUG
            printf("Remove MRL entry %d\n",seqno);
#endif
            Clean_RList(node,seqno);
        }
    }
}

void Create_RList(GlomoNode *node, int valid)
{
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;
    int count,count2,count3,count4;
    int i, needack=0, okdel;

    WrpMrlTuple *head, *hptr, *htemp;

#ifdef DEBUG
    printf("#%u: Create_RList(%d,%d)\n",node->nodeAddr,wrp->SEQNO,valid);
#endif
    /* NeighborSet <- Ni */
    /* Julian: doesn't do anything */

    wrp->MRL[wrp->SEQNO].bitmap = pc_malloc(sizeof(int)*node->numNodes);
    assert(wrp->MRL[wrp->SEQNO].bitmap);

    /* bitmap[] <- 0; RetransmissionTimer <- x */
    for (count=0; count<node->numNodes; count++)
        wrp->MRL[wrp->SEQNO].bitmap[count] = wrp->responseList[count];

    /* Julian: retxtimer is a relic, bitmap not necessary */
   
    /* add updates to RList */
    for (count=0; count < node->numNodes; count++)
        if ((wrp->Ni[count]==1)&&(wrp->responseList[count]==1))
            needack = 1;
    if (needack==1)
    {
        wrp->MRL[wrp->SEQNO].dat = pc_malloc(sizeof(WrpTuple)*valid);
        assert(wrp->MRL[wrp->SEQNO].dat);
        wrp->MRL[wrp->SEQNO].retx_counter = WRP_MRL_RETX_CONST;
        wrp->MRL[wrp->SEQNO].retx_count = 0;
        wrp->MRL[wrp->SEQNO].MRLsize = valid;
        for (count2=0; count2 < valid; count2++)
           wrp->MRL[wrp->SEQNO].dat[count2] = wrp->LIST[count2];
        for (count2=0; count2 < valid; count2++)
            for (i=0; i<WRP_MAX_SEQ_NUM; i++)
                if ((wrp->MRL[i].MRLsize > 0)&&(i != wrp->SEQNO))
                {
#ifdef DEBUG
                    printf("comparing entry %d to entry %d\n",wrp->SEQNO,i);
#endif
                    for (count3=0; count3 < wrp->MRL[i].MRLsize; count3++)
                        if ((wrp->MRL[i].dat[count3].u==
                             wrp->MRL[wrp->SEQNO].dat[count2].u) &&
                            (wrp->MRL[i].dat[count3].j==
                             wrp->MRL[wrp->SEQNO].dat[count2].j))
                        {
#ifdef DEBUG
                            printf("OLD ENTRY\n");
#endif
                            if (wrp->MRL[i].MRLsize==1)
                            {
#ifdef DEBUG
                                printf("Only One\n");
#endif
                                Clean_RList(node,i);
                            }
                            else
                            {
                                for (count4=count3;count4
                                     <wrp->MRL[i].MRLsize-1; count4++)
                                    wrp->MRL[i].dat[count4] =
                                        wrp->MRL[i].dat[count4+1];
                                    wrp->MRL[i].MRLsize--;
                                    count3--;
                            }

                        }
                }
    }
    /* seqno <- seqno + 1   Julian: moved here from top */
    wrp->SEQNO = (wrp->SEQNO + 1) % WRP_MAX_SEQ_NUM;
}

void printDTable(GlomoNode *node)
{
    GlomoRoutingWrp *wrp = (GlomoRoutingWrp *)node->appData.routingVar;

    int count, count2;

    printf("Distance Table for Node #%u\n ",node->nodeAddr);
    for (count = 0; count < node->numNodes; count++)
    {
        if (wrp->N[count]==0)
            continue;
        for (count2 = 0; count2 < node->numNodes; count2++)
        {
           if ( (count==node->nodeAddr) || (count2 == node->nodeAddr) )
               continue;
           if (wrp->Ni[count2]==0)
               continue;
           printf("(%d-%d,%d p%d=%d) ",node->nodeAddr,
               wrp->DTable[count].dest, wrp->DTable[count].dat[count2].via,
               wrp->DTable[count].dat[count2].pred,
               wrp->DTable[count].dat[count2].dist);
        }
        printf("\n ");
    }
    printf("\n");

}

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

    printf("Routing Table for Node #%u\n  ",node->nodeAddr);
    for (count = 0; count < node->numNodes; count++)
    {
        if (wrp->N[count] == 0)
            continue;
        printf("(to %d via %d pred=%d dist=%d)\n  ",wrp->RTable[count].dest,
            wrp->RTable[count].succ, wrp->RTable[count].pred,
            wrp->RTable[count].dist);
    }
    printf("\n");

}

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

    printf("Link Table for Node #%d\n  ",node->nodeAddr);
    for (count = 0; count < node->numNodes; count++)
    {
        if (wrp->Ni[count]==0)
            continue;
        printf("(to %d = %d) ",wrp->LTable[count].dest,
            wrp->LTable[count].dist);
    }
    printf("\n\n");
}