infopacket.java

中間件開發详细说明：清华大学J2EE教程讲义（ppt）-Tsinghua University J2EE tutorial lectures (ppt) [上载源码成为会员下载此源码] [成为VIP会

/*
 * ** Network and Service Differentiation Extensions to GridSim 3.0 **
 *
 * Gokul Poduval & Chen-Khong Tham
 * Computer Communication Networks (CCN) Lab
 * Dept of Electrical & Computer Engineering
 * National University of Singapore
 * August 2004
 * NOTE: this is an experimental implementation subject to continuous
 * modification and enhancement, and is not an official release
 *
 * Licence: GPL - http://www.gnu.org/copyleft/gpl.html
 *
 * InfoPacket.java - Implementation of a Information Packet.
 *
 */

package gridsim.net;

import java.text.DecimalFormat;
import java.util.* ;
import gridsim.* ;


/**
 * InfoPacket class can be used to gather information from the network layer.
 * An InfoPacket traverses the network topology similar to a
 * {@link gridsim.net.NetPacket},
 * but it collects information like bandwidths, and Round Trip Time etc. It is
 * the equivalent of ICMP in physical networks.
 * <p>
 * You can set all the parameters to an InfoPacket that can be applied to a
 * NetPacket. So if you want to find out the kind of information that a
 * particular type of NetPacket is experiencing, set the size and network
 * class of an InfoPacket to the same as the NetPacket, and send it to the same
 * destination from the same source.
 *
 * @since GridSim Toolkit 3.1
 * @author Gokul Poduval & Chen-Khong Tham, National University of Singapore
 * @invariant $none
 */

public class InfoPacket implements Packet
{
    private String name_;   // packet name
    private long size_;     // size of this packet
    private int packetID_;  // id of this packet
    private int srcID_;     // original sender id
    private int destID_;    // destination id
    private int last_;      // last hop
    private int tag_;       // whether going or returning
    private int numHop_;    // number of hops
    private long pingSize_; // original ping size
    private int netServiceType_;    // level of service type
    private double bandwidth_;      // bottleneck
    private Vector entities_;       // list of entity IDs
    private Vector entryTimes_;     // list of entry times
    private Vector exitTimes_;      // list of exit times
    private Vector baudRates_;      // list of entity's baud rate
    private DecimalFormat num_;     // formatting the decimal points


    /**
     * Constructs a new Information packet.
     *
     * @param name   Name of this packet
     * @param packetID  The ID of this packet
     * @param size   size of the packet
     * @param srcID  The ID of the entity that sends out this packet
     * @param destID The ID of the entity to which this packet is destined
     * @param netServiceType the class of traffic this packet belongs to
     *
     * @pre name != null
     * @post $none
     */
    public InfoPacket(String name, int packetID, long size, int srcID,
                      int destID, int netServiceType)
    {
        this.name_ = name;
        this.packetID_ = packetID;
        this.srcID_ = srcID;
        this.destID_ = destID;
        this.size_ = size;
        this.netServiceType_ = netServiceType;

        init();
    }

    /**
     * Initialises common attributes
     * @pre $none
     * @post $none
     */
    private void init()
    {
        this.last_ = srcID_;
        this.tag_ = GridSimTags.INFOPKT_SUBMIT;
        this.bandwidth_ = -1;
        this.numHop_ = 0;
        this.pingSize_ = size_;

        if (name_ != null)
        {
            this.entities_ = new Vector();
            this.entryTimes_ = new Vector();
            this.exitTimes_ = new Vector();
            this.baudRates_ = new Vector();
            num_ = new DecimalFormat("#0.000#");   // 4 decimal spaces
        }
    }

    /**
     * Returns the ID of this packet
     * @return packet ID
     * @pre $none
     * @post $none
     */
    public int getID() {
        return packetID_;
    }

    /**
     * Sets original size of ping request
     * @param size  ping data size (in bytes)
     * @pre size >= 0
     * @post $none
     */
    public void setOriginalPingSize(long size) {
        this.pingSize_ = size;
    }

    /**
     * Gets original size of ping request
     * @return original size
     * @pre $none
     * @post $none
     */
    public long getOriginalPingSize() {
        return pingSize_;
    }

    /**
     * Returns a human-readable information of this packet.
     *
     * @return description of this packet
     * @pre $none
     * @post $none
     */
    public String toString()
    {
        if (name_ == null) {
            return "Empty InfoPacket that contains no ping information.";
        }

        int SIZE = 1000;   // number of chars
        StringBuffer sb = new StringBuffer(SIZE);
        sb.append("Ping information for " + name_ + "\n");
        sb.append("Entity Name\tEntry Time\tExit Time\t Bandwidth\n");
        sb.append("----------------------------------------------------------\n");

        String tab = "    ";  // 4 spaces
        for (int i = 0 ; i < entities_.size(); i++)
        {
            int resID = ( (Integer) entities_.get(i) ).intValue();
            sb.append(GridSim.getEntityName(resID) + "\t\t");

            String entry = getData(entryTimes_, i);
            String exit = getData(exitTimes_, i);
            String bw = getData(baudRates_, i);

            sb.append(entry + tab + tab + exit + tab + tab + bw + "\n");
        }

        sb.append("\nRound Trip Time : " +
                  num_.format(this.getTotalResponseTime()) );
        sb.append(" seconds");
        sb.append("\nNumber of Hops  : " + this.getNumHop() );
        sb.append("\nBottleneck Bandwidth : " + bandwidth_ + " bits/s");
        return sb.toString();
    }

    /**
     * Gets relevant data from a list
     * @param v  a list
     * @param index   the location in a list
     * @pre v != null
     * @post index > 0
     */
    private String getData(Vector v, int index)
    {
        String result;
        try
        {
            Double obj = (Double) v.get(index);
            double id = obj.doubleValue();
            result = num_.format(id);
        }
        catch (Exception e) {
            result = "    N/A" ;
        }

        return result;
    }

    /**
     * Gets the size of this packet.
     *
     * @return size of the packet.
     * @pre $none
     * @post $none
     */
    public long getSize() {
        return size_;
    }

    /**
     * Sets the size of this packet
     * @param size  size of the packet
     * @return <tt>true</tt> if it is successful, <tt>false</tt> otherwise
     * @pre size >= 0
     * @post $none
     */
    public boolean setSize(long size)
    {
        if (size < 0) {
            return false;
        }

        this.size_ = size;
        return true;
    }

    /**
     * Gets the id of the entity to which the packet is destined.
     *
     * @return the desination ID
     * @pre $none
     * @post $none
     */
    public int getDestID() {
        return destID_;
    }

    /**
     * Gets the id of the entity that sent out this packet
     *
     * @return the source ID
     * @pre $none
     * @post $none
     */
    public int getSrcID() {
        return srcID_;
    }

    /**
     * Returns the number of hops that this packet has traversed. Since the
     * packet takes a round trip, the same router may have been traversed
     * twice.
     *
     * @return the number of hops this packet has traversed
     * @pre $none
     * @post $none
     */
    public int getNumHop()
    {
        int PAIR = 2;
        return ((numHop_ - PAIR) + 1) / PAIR;
    }

    /**
     * Gets the total time that this packet has spent in the network. This is
     * basically the RTT. Dividing this by half should be the approximate
     * latency.
     * <p>
     * RTT is taken as the final entry time - first exit time.
     * @return total round time
     * @pre $none
     * @post $none
     */
    public double getTotalResponseTime()
    {
        if (exitTimes_ == null || entryTimes_ == null) {
            return 0;
        }

        double time = 0;
        try
        {
            double startTime = ((Double)exitTimes_.firstElement()).doubleValue();
            double receiveTime = ((Double)entryTimes_.lastElement()).doubleValue();
            time = receiveTime - startTime;
        }
        catch(Exception e) {
            time = 0;
        }

        return time;
    }

    /**
     * Returns the bottleneck bandwidth between the source and the destination
     *
     * @return the bottleneck bandwidth
     * @pre $none
     * @post $none
     */
    public double getBaudRate() {
        return bandwidth_;
    }

    /**
     * This method should be called by network entities that count as hops, for
     * e.g. Routers or GridResources. It should not be called by links etc.
     *
     * @param id    the id of the hop that this InfoPacket is traversing
     * @pre id > 0
     * @post $none
     */
    public void addHop(int id)
    {
        if (entities_ == null) {
            return;
        }

        numHop_++;
        entities_.add( new Integer(id) );
    }

    /**
     * This method should be called by routers and other entities
     * when this InfoPacket reaches them along with the current simulation time.
     *
     * @param time  current simulation time, use
     *              {@link gridsim.GridSim#clock()} to obtain this
     * @pre time >= 0
     * @post $none
     */
    public void addEntryTime(double time)
    {
        if (entryTimes_ == null) {
            return;
        }

        if (time < 0) {
            time = 0.0;
        }

        entryTimes_.add( new Double(time) );
    }

    /**
     * This method should be called by routers and other entities
     * when this InfoPacket is leaving them. It should also supply the current
     * simulation time.
     *
     * @param time  current simulation time, use
     *              {@link gridsim.GridSim#clock()} to obtain this
     * @pre time >= 0
     * @post $none
     */
    public void addExitTime(double time)
    {
        if (exitTimes_ == null) {
            return;
        }

        if (time < 0) {
            time = 0.0;
        }

        exitTimes_.add( new Double(time) );
    }

    /**
     * Every entity that the InfoPacket traverses should add the baud rate of
     * the link on which this packet will be sent out next.
     * @param baudRate  the entity's baud rate in bits/s
     * @pre baudRate > 0
     * @post $none
     */
    public void addBaudRate(double baudRate)
    {
        if (baudRates_ == null) {
            return;
        }

        baudRates_.add( new Double(baudRate) );
        if (bandwidth_ < 0 || baudRate < this.bandwidth_) {
            this.bandwidth_ = baudRate;
        }
    }

    /**
     * Returns the list of all the bandwidths that this packet has traversed
     *
     * @return a Double Array of links bandwidths
     * @pre $none
     * @post $none
     */
    public Object[] getDetailBaudRate()
    {
        if (baudRates_ == null) {
            return null;
        }

        return baudRates_.toArray();
    }

    /**
     * Returns the list of all the hops that this packet has traversed.
     *
     * @return an Integer Array of hop ids
     * @pre $none
     * @post $none
     */
    public Object[] getDetailHops()
    {
        if (entities_ == null) {
            return null;
        }

        return entities_.toArray();
    }

    /**
     * Returns the list of all entry time that this packet has traversed.
     * @return an Integer Array of entry time
     * @pre $none
     * @post $none
     */
    public Object[] getDetailEntryTimes()
    {
        if (entryTimes_ == null) {
            return null;
        }

        return entryTimes_.toArray();
    }

    /**
     * Returns the list of all exit time that this packet has traversed.
     * @return an Integer Array of exit time
     * @pre $none
     * @post $none
     */
    public Object[] getDetailExitTimes()
    {
        if (exitTimes_ == null) {
            return null;
        }

        return exitTimes_.toArray();
    }

    /**
     * Gets an entity ID from the last hop that this packet has traversed.
     * @return an entity ID
     * @pre $none
     * @post $none
     */
    public int getLast() {
        return last_;
    }

    /**
     * Sets an entity ID from the last hop that this packet has traversed.
     * @param last  an entity ID from the last hop
     * @pre last > 0
     * @post $none
     */
    public void setLast(int last) {
        this.last_ = last;
    }

    /**
     * Gets the network service type of this packet
     * @return the network service type
     * @pre $none
     * @post $none
     */
    public int getNetServiceType() {
        return netServiceType_ ;
    }

    /**
     * Sets the network service type of this packet
     * @param netServiceType    the packet's network service type
     * @pre netServiceType >= 0
     * @post $none
     */
    public void setNetServiceType(int netServiceType) {
        this.netServiceType_ = netServiceType ;
    }

    /**
     * Gets this packet tag
     * @return this packet tag
     * @pre $none
     * @post $none
     */
    public int getTag() {
        return tag_ ;
    }

    /**
     * Sets the tag of this packet
     * @param tag   the packet's tag
     * @return <tt>true</tt> if successful, <tt>false</tt> otherwise
     * @pre tag > 0
     * @post $none
     */
    public boolean setTag(int tag)
    {
        boolean flag = false;
        switch(tag)
        {
            case GridSimTags.INFOPKT_SUBMIT:
            case GridSimTags.INFOPKT_RETURN:
                this.tag_ = tag;
                flag = true;
                break;

            default:
                flag = false;
                break;
        }

        return flag;
    }

    /**
     * Sets the destination ID for this packet
     * @param id    this packet's destination ID
     * @pre id > 0
     * @post $none
     */
    public void setDestID(int id) {
        this.destID_ = id;
    }

} // end class