routingtest.java

state strech routing protocl

/* ex: set tabstop=4 shiftwidth=4 expandtab:*/ 
/* $Id: RoutingTest.java,v 1.9 2006/10/03 06:51:26 maoy Exp $ */


package net.tinyos.cr;

import java.io.*;
import java.util.*;

import net.tinyos.message.*;
import net.tinyos.cr.messages.*;
import net.tinyos.packet.*;
import net.tinyos.util.*;

import net.tinyos.testbed.*;

public class RoutingTest {
    public GatewayMap testbed;
 
    public static final byte COMPONENTS = 2;


    private static final int[] REPS =      {25000,1000,2000,5000};
    private static final int[] INTERVALS = {1000,500,250,100};
   
    //private static final int INITIAL_INTERVAL = 3600000;
    //private static final int INITIAL_INTERVAL = 300000;
    private static final int INITIAL_INTERVAL = 120000;
    private static final int initial_interval = 0;
    
    private Vector motes;
    private int step = 0;
    private int reps = 0;
    private int delay = 0;
    public static int [] randperm(int n){
        /* return an array from 0,..,n-1 with random order
         */
        
        int [] shuffle = new int[n];
        int i,j,aux;
        for (i = 0; i < n; i++) {
            shuffle[i] = i;
        }
        //shuffle the motes
        //System.out.print("Before:");
        //for (i = 0; i < shuffle.length; i++) {
        //    System.out.print(shuffle[i] + " ");
        //}
        //System.out.println();
        
        for (i = n; --i > 0;) {
            j = (int)(Math.random()*(i+1));
            if (j != i) {
                aux = shuffle[i];
                shuffle[i] = shuffle[j];         
                shuffle[j] = aux;
            } 
        }
        //System.out.print("After:");
        //for (i = 0; i < shuffle.length; i++) {
        //    System.out.print(shuffle[i] + " ");
        //}
        //System.out.println();
        return shuffle;
        
    }
    public static int randint(int n){
        /* random number between 1..n*/
        return 1+(int)Math.floor( Math.random()*n);
    }
    public RoutingTest(GatewayMap testbed, String [] args) {
        motes = new Vector();
        this.testbed = testbed;
        int n_gatewayMotes = testbed.gatewayMotes.size();
        for (int i=1;i<=n_gatewayMotes;i++) {
            motes.addElement(new S4TestBedMote(i));
        }
    
        //step = 0; 
        //reps = REPS[step];
        //delay = INTERVALS[step];
     
        //Initial delay
        /*
        System.out.println("Starting Throughput test. Sleeping for " + (initial_interval / 60) + "minutes");
        try {
            Thread.sleep(initial_interval*1000);
        } catch (Exception e) {e.printStackTrace(System.err); System.exit(0);}
        */
        
        if (args[1].equals("none"))
            return;

        System.out.println("collecting coordinates from all destinations actively. please wait");
        boolean finished = false;
        while (! finished){
            try {
                Thread.sleep(1000); //sleep 1 second
            } catch (Exception e) {e.printStackTrace(System.err); System.exit(0);}
            finished = true;
            for (int i=0;i<n_gatewayMotes;i++){
                if (((S4TestBedMote)motes.elementAt(i)).countValid() <= COMPONENTS) {
                    finished = false;
                    System.out.println("Fetching "+(i+1)+" coord");
                    short [] c = testbed.getCoords(i+1);
                    ((S4TestBedMote)motes.elementAt(i)).setCoords(c);
                    break;
                }
            }
        }
        System.out.println("OK!! We've got all beacon vectors from the destinations");
        
        if (args[1].equals("single"))
            singleFlow(args);
        if (args[1].equals("multi"))
            multiFlow(args);
    }
    public void multiFlow(String [] args) {
        int n_flows = Integer.parseInt(args[2]);
        int flow_interval = Integer.parseInt(args[3]);
        int flow_time = 10; //in minutes
        int n_gatewayMotes = testbed.gatewayMotes.size();
        int initial_sleep = 2*flow_interval/1000;
        if (args.length>=5)
            flow_time = Integer.parseInt(args[4]);
        
        long flow_packets = flow_time*60*1000L/flow_interval;
        S4TestBedMote.log("***** Starting now with multi flow interval: " + flow_interval);
        for (int i=0;i<n_flows;i++){
            int source = 0;
            int dest = 0;
            while (source == dest) {
                source = testbed.getRandomMoteID();
                dest = randint(n_gatewayMotes);
            }
            //route from source to dest
            S4TestBedMote.log("attempt create a flow from " + source + " to " + dest);

            S4TestBedMote d = (S4TestBedMote)motes.elementAt(dest-1);
            short bcn = d.getClosestBeacon();

            String cmd = Integer.toString(source)+" adv_route_to "
                +Integer.toString(bcn)+" "+Integer.toString(dest)
                +" "+Integer.toString(initial_sleep)
                +" "+Long.toString(flow_packets)
                +" "+Integer.toString(flow_interval);
            long t_before = new Date().getTime();
            S4CommandResponseMessage m = testbed.runCommand(cmd,false);
            if (m==null) {
                S4TestBedMote.log("attempt failed  from " + source + " to " + dest);
                i--;
            }
            else
                S4TestBedMote.log("Multiflow Routing from " + source + " to " + dest);
                
            try {
                long sleep_delay = new Date().getTime()-t_before -flow_interval/n_flows;
                S4TestBedMote.log("sleep:"+ sleep_delay);
                if (sleep_delay>0)
                    Thread.sleep(sleep_delay);
            } catch (Exception e) {e.printStackTrace(System.err); System.exit(0);}
            
        }
        
        try {
            long sleep_delay = flow_time*60000+initial_sleep*1000;
            S4TestBedMote.log("expecting # of delivered packets:"+ flow_packets*n_flows);
            Thread.sleep(sleep_delay);
            S4TestBedMote.log("Time is up. sleep half minutes more");
            Thread.sleep(30*1000);
            System.exit(0);
        } catch (Exception e) {e.printStackTrace(System.err); System.exit(0);}
        
    }
    public void singleFlow(String [] args) {
        //delay (ms) number_of_packets
        delay = Integer.parseInt(args[2]);
        int total_trials = Integer.parseInt(args[3]);

        try {
            Thread.sleep(1000);
            } catch (Exception e) {e.printStackTrace(System.err); System.exit(0);}
        S4CommandResponseMessage m = testbed.runCommand("all dump_link",true);
        
        //int [] shuffle;
        //shuffle = randperm(motes.size());
        Date t = new Date();
        long last_sent_t = t.getTime();
        int n_trials = 0;


        S4TestBedMote.log("***** Starting now with interval: " + delay);

        boolean [] deadMotes = new boolean[50]; 
        while (n_trials < total_trials) { //total of 5000 trials
            int source = testbed.getRandomMoteID();
            int n_gatewayMotes = testbed.gatewayMotes.size();
            int dest = randint(n_gatewayMotes);

            if (source ==dest)
                continue; //try again
            if (deadMotes[source] || deadMotes[dest]) continue;
 
            n_trials++;
           
            //route from source to dest
            S4TestBedMote.log("attempt to route::: from:" + source + ",to:" + dest);

            S4TestBedMote d = (S4TestBedMote)motes.elementAt(dest-1);
            short bcn = d.getClosestBeacon();

            //System.out.println("closest bcn" + bcn);
            String cmd = Integer.toString(source)+" route_to "+
                Integer.toString(bcn)+" "+Integer.toString(dest);
            //System.out.println(cmd);
            last_sent_t = new Date().getTime();
            m = testbed.runCommand(cmd,false);
            if (m==null){
                S4TestBedMote.log("attempt failed to route from " + source + " to " + dest);
                S4TestBedMote.log("Noted dead node " + source);
                deadMotes[source] = true;
            }
            else
                S4TestBedMote.log("Routing from " + source + " to " + dest);
                
            //now choose the amount of sleep
            if (reps-- == 0) {
                if (++step == INTERVALS.length) {
                    System.exit(0);
                }
                //delay = INTERVALS[step];
                reps = REPS[step];
                //System.out.println("***** Starting now with interval: " + delay);
            } 
            try {
                long sleep_delay = delay - (new Date().getTime()-last_sent_t);
                S4TestBedMote.log(sleep_delay+" HERE I AM");
                if (sleep_delay>0) {
                    Thread.sleep(sleep_delay);
                }else{
                    S4TestBedMote.log("command took longer time to finish than interval");
                }
                     
            } catch (Exception e) {e.printStackTrace(System.err); System.exit(0);}
        }
    }

    private static void printUsage() {
        System.err.println("usage: RoutingTest <gateway map file> none");
        System.err.println("usage: RoutingTest <gateway map file> single <single_delay> <number_of_packets>");
        System.err.println("usage: RoutingTest <gateway map file> multi n_flow flow_interval flow_length(minute)");
    }

    public static void main(String[] args) throws IOException {
        GatewayMap testbed;
        int n_nodes;

        String host;
        int baseport;
        int initial_interval=60;
        if (args.length >= 2) {
            try {
                testbed = new GatewayMap(args[0]);
                RoutingTest pl = new RoutingTest(testbed, args);

                //added by Feng Wang on Sept. 28, to get statistics
                n_nodes = testbed.n_totalMotes;
                String cmd = "all get_stats";
                S4CommandResponseMessage m = testbed.runCommand(cmd,true);
                /*
                for (int i=1;i<=n_nodes;i++) {
                    String cmd = Integer.toString(i)+" get_stats";
                    S4CommandResponseMessage m = testbed.runCommand(cmd,true);
                }*/

            } catch(FileNotFoundException e) {
                System.err.println(e);
                System.exit(-1);
            }
        } else {
            printUsage();
            System.exit(-1);
        }
    }
}