Thread: [Gridsim-commits] SF.net SVN: gridsim: [112] branches/gridsim4.0-branch2/source/gridsim/net/ flow/F

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 112
          http://gridsim.svn.sourceforge.net/gridsim/?rev=112&view=rev
Author:   brobergj
Date:     2008-02-18 18:40:39 -0800 (Mon, 18 Feb 2008)

Log Message:
-----------
*FlowBuffer replaces FlowInput/FlowOutput approach
*FlowBuffer acts as both a input and output port for simulation entities and as such it is a central point of control

Added Paths:
-----------
    branches/gridsim4.0-branch2/source/gridsim/net/flow/FlowBuffer.java

Added: branches/gridsim4.0-branch2/source/gridsim/net/flow/FlowBuffer.java
===================================================================

--- branches/gridsim4.0-branch2/source/gridsim/net/flow/FlowBuffer.java	                        (rev 0)
+++ branches/gridsim4.0-branch2/source/gridsim/net/flow/FlowBuffer.java	2008-02-19 02:40:39 UTC (rev 112)
@@ -0,0 +1,895 @@
+/*
+ * Title:        GridSim Toolkit
+ * Description:  GridSim (Grid Simulation) Toolkit for Modeling and Simulation
+ *               of Parallel and Distributed Systems such as Clusters and Grids
+ * Licence:      GPL - http://www.gnu.org/copyleft/gpl.html
+ *
+ * Author: James Broberg & Anthony Sulistio (Adapted from original Output.java)
+ */
+
+package gridsim.net.flow;
+
+import gridsim.*;
+import gridsim.net.*;
+import gridsim.util.*;
+
+import eduni.simjava.*;
+
+import java.util.*;
+
+
+/**
+ * GridSim Output defines a port through which a simulation entity sends
+ * data to the simulated network.
+ * <p>
+ * It maintains an event queue to serialize
+ * the data-out-flow and delivers to the destination entity.
+ * It works along with Input entity to simulate network
+ * communication delay. Simultaneous outputs can be modeled by using multiple
+ * instances of this class
+ *
+ * @author       Manzur Murshed and Rajkumar Buyya
+ * @since        GridSim Toolkit 1.0
+ * @invariant $none
+ */
+public class FlowBuffer extends Sim_entity implements NetIO
+{
+    private Sim_port outPort_;      // output port
+    private Link link_;             // a link to this output entity
+    private double baudRate_;       // baud rate of this entity
+    private final int SIZE = 8;     // 1 byte in bits
+    private int pktID_;             // packet ID counter
+    private Vector outPacketList_;     // store a list of packets
+    private HashMap<Integer, Packet> activeFlows_; // stores a list of active Flows
+    private Random random_;         // selects to which junk packets go to
+    private TrafficGenerator gen_;  // background traffic generator
+    private ArrayList list_;        // list of resources + user entities
+    private boolean hasStarted_;    // a flag for background traffic has started
+    private static final int BITS = 8;      // 1 byte = 8 bits
+
+
+    /**
+     * Allocates a new Output object
+     * @param name         the name of this object
+     * @param baudRate     the communication speed
+     * @throws NullPointerException This happens when creating this entity
+     *                  before initializing GridSim package or this entity name
+     *                  is <tt>null</tt> or empty
+     * @pre name != null
+     * @pre baudRate >= 0.0
+     * @post $none
+     */
+    public FlowBuffer(String name, double baudRate) throws NullPointerException
+    {
+        super(name);
+        this.baudRate_ = baudRate;
+        link_ = null;
+        outPacketList_ = null;
+        activeFlows_ = null;
+        pktID_ = 0;
+
+        outPort_ = new Sim_port("output_buffer");
+        super.add_port(outPort_);
+
+        // for sending background traffic
+        gen_  = null;
+        list_ = null;
+        random_ = null;
+        hasStarted_ = false;
+    }
+
+    /**
+     * Sets the background traffic generator for this entity.
+     * <p>
+     * When simulation starts, this entity will automatically sends junk
+     * packets to resource entities.
+     * @param gen   a background traffic generator
+     * @return <tt>true</tt> if successful, <tt>false</tt> otherwise
+     * @pre gen != null
+     * @post $none
+     */
+    public boolean setBackgroundTraffic(TrafficGenerator gen)
+    {
+        if (gen == null) {
+            return false;
+        }
+
+        gen_ = gen;
+        if (list_ == null) {
+            list_ = new ArrayList();
+        }
+
+        return true;
+    }
+
+    /**
+     * Sets the background traffic generator for this entity.
+     * <p>
+     * When simulation starts, this entity will automatically sends junk
+     * packets to resource entities and other entities. <br>
+     * NOTE: Sending background traffic to itself is not supported.
+     *
+     * @param gen       a background traffic generator
+     * @param userName  a collection of user entity name (in String object).
+     * @return <tt>true</tt> if successful, <tt>false</tt> otherwise
+     * @pre gen != null
+     * @pre userName != null
+     * @post $none
+     */
+    public boolean setBackgroundTraffic(TrafficGenerator gen,
+                                        Collection userName)
+    {
+        if (gen == null || userName == null) {
+            return false;
+        }
+
+        boolean flag = true;
+        try
+        {
+            gen_ = gen;
+            if (list_ == null) {
+                list_ = new ArrayList();
+            }
+
+            // iterates through each list to check whether it is a valid
+            // entity name or not
+            Iterator it = userName.iterator();
+            int id = -1;
+            while( it.hasNext() )
+            {
+                String name = (String) it.next();
+
+                // check whether it is sending to itself
+                id = GridSim.getEntityId("Output_" + name);
+                if (id == super.get_id())
+                {
+                    System.out.println(super.get_name() +
+                        ".setBackgroundTraffic(): Warning - can not send " +
+                        "junk packets to itself.");
+                    continue;
+                }
+
+                // get the ID of other entity
+                id = GridSim.getEntityId(name);
+                if (id > 0)
+                {
+                    Integer obj = new Integer(id);
+                    list_.add(obj);
+                }
+                // ignore for invalid entity
+                else
+                {
+                    System.out.println(super.get_name() +
+                        ".setBackgroundTraffic(): Warning - invalid entity " +
+                        "name for \"" + name + "\".");
+                }
+            }
+        }
+        catch(Exception e) {
+            flag = false;
+        }
+
+        return flag;
+    }
+
+    /**
+     * Sets this entity's link. This should be used only if the network
+     * extensions are being used.
+     *
+     * @param link the link to which this Output entity should send data
+     * @pre link != null
+     * @post $none
+     */
+    public void addLink(Link link)
+    {
+        this.link_ = link;
+        baudRate_ = link_.getBaudRate();
+        outPacketList_ = new Vector();
+        activeFlows_ = new HashMap();
+    }
+
+    /**
+     * Gets the baud rate
+     * @return the baud rate
+     * @deprecated As of GridSim 2.1, replaced by {@link #getBaudRate()}
+     * @pre $none
+     * @post $result >= 0.0
+     */
+    public double GetBaudRate() {
+        return this.getBaudRate();
+    }
+
+    /**
+     * Gets the baud rate
+     * @return the baud rate
+     * @pre $none
+     * @post $result >= 0.0
+     */
+    public double getBaudRate() {
+        return baudRate_;
+    }
+
+    /**
+     * Gets the I/O real number based on a given value
+     * @param value  the specified value
+     * @return real number
+     * @deprecated As of GridSim 2.1, replaced by {@link #realIO(double)}
+     * @pre $none
+     * @post $result >= 0.0
+     */
+    public double real_io(double value) {
+        return this.realIO(value);
+    }
+
+    /**
+     * Gets the I/O real number based on a given value
+     * @param value  the specified value
+     * @return real number
+     * @pre $none
+     * @post $result >= 0.0
+     */
+    public double realIO(double value) {
+        return GridSimRandom.realIO(value);
+    }
+
+    /**
+     * A method that gets one process event at one time until the end
+     * of a simulation, then delivers an event to the entity (its parent)
+     * @pre $none
+     * @post $none
+     */
+    public void body()
+    {
+    	
+    	//System.out.println("Hello FlowOutput");
+
+        // find out ids for entities that are not part of simulation network
+        // topology, such as GIS, GridSimShutdown and GridStatistics
+        int gisID = GridSim.getGridInfoServiceEntityId();
+        int statID = GridSim.getGridStatisticsEntityId();
+        int shutdownID = GridSim.getGridSimShutdownEntityId();
+
+        // start generating some junk packets or background traffic
+        startBackgroundTraffic();
+
+        // Process incoming events
+        while ( Sim_system.running() )
+        {
+            Sim_event ev = new Sim_event();
+            super.sim_get_next(ev);     // get the next event in the queue
+
+            // if the simulation finishes then exit the loop
+            if (ev.get_tag() == GridSimTags.END_OF_SIMULATION) {
+                break;
+            }
+            
+        	System.out.println(super.get_name() + ".body(): ev.get_tag() is " + ev.get_tag());
+
+            // handle different types of incoming events
+            switch ( ev.get_tag() )
+            {
+                case GridSimTags.SEND_PACKET:
+                	System.out.println(super.get_name() + ".body(): sendPacket() + at time = " + GridSim.clock());
+                    sendPacket();
+                    break;
+
+                // submit ping() request
+                case GridSimTags.INFOPKT_SUBMIT:
+                	System.out.println(super.get_name() + ".body(): sendInfoPacket() + at time = " + GridSim.clock());
+                    sendInfoPacket(ev);
+                    break;
+
+                // replying ping() request from another entity
+                case GridSimTags.INFOPKT_RETURN:
+                	System.out.println(super.get_name() + ".body(): returnInfoPacket() + at time = " + GridSim.clock());
+                    returnInfoPacket(ev);
+                    break;
+
+                // activate background traffic
+                case GridSimTags.JUNK_PKT:
+                    generateBackgroundTraffic();
+                    break;
+                    
+                case GridSimTags.PKT_FORWARD:
+                	System.out.println(super.get_name() + ".body(): getDataFromLink() + at time = " + GridSim.clock());
+                	getDataFromLink(ev);
+                	break;
+                	
+                // Check if initial flow duration estimation was accurate
+                case GridSimTags.FLOW_HOLD:
+                	System.out.println(super.get_name() + ".body(): checkForecast() + at time = " + GridSim.clock());
+                    checkForecast(ev);
+                	break;
+
+                default:
+                    defaultSend(ev, gisID, statID, shutdownID);
+                    break;
+            }
+        }
+        
+        System.out.println(super.get_name() + ":%%%% Exiting body() at time " +
+                GridSim.clock() );
+    }
+
+    private void checkForecast(Sim_event ev) {
+    	int pktID = (Integer) ev.get_data();
+    	FlowPacket fp = null;
+    
+        System.out.println(super.get_name() + ".checkForecast(): checking pkt id # " + pktID);
+    	
+        // If flow hasn't already finished
+        if ((fp = (FlowPacket) activeFlows_.get(pktID)) != null) {
+            Object data = fp.getData();
+            IO_data io = new IO_data( data, fp.getSize(),
+            		                  outPort_.get_src());
+            super.sim_schedule(outPort_, GridSimTags.SCHEDULE_NOW, fp.getTag() , io.getData());
+        } else {
+            System.out.println(super.get_name() + ".checkForecast(): pkt id # " + pktID + " already removed");
+
+        }
+		
+	}
+
+	/**
+     * Generates few junk packets at the given interval
+     * @pre $none
+     * @post $none
+     */
+    private synchronized void generateBackgroundTraffic()
+    {
+        // get the next inter-arrival time for these junk packets
+        long time = gen_.getNextPacketTime();
+
+        // get the sending pattern
+        int pattern = gen_.getPattern();
+
+        // for initial start-up, get the list of all resources first
+        if (hasStarted_ == false)
+        {
+            // get list of resource IDs from GIS
+            LinkedList resList = GridSim.getGridResourceList();
+
+            // if the list is empty then schedule the next time
+            if (resList == null && list_.size() == 0)
+            {
+                super.sim_schedule(super.get_id(), time, GridSimTags.JUNK_PKT);
+                return;
+            }
+
+            hasStarted_ = true;
+            list_.addAll(resList);  // add resource IDs into the current list
+
+            // sets the sending pattern
+            if (pattern == TrafficGenerator.SEND_ONE_ONLY && random_ == null) {
+                random_ = new Random();
+            }
+        }
+
+        // get the required info for generating this background traffic
+        long size = gen_.getNextPacketSize();   // packet size
+        long freq = gen_.getNextPacketFreq();   // packet freq
+        int type = gen_.getServiceType();       // packet type
+        int tag = GridSimTags.JUNK_PKT;         // packet tag
+
+        // we need to packetsize the data, all packets are sent with size MTU.
+        // only the last packet contains the data, the receiver should
+        // throw away all other packets
+        int MTU = link_.getMTU();
+        int numPackets = (int) Math.ceil( size / (MTU * 1.0) );
+
+        /*********   // DEBUG info
+        System.out.println();
+        System.out.println(super.get_name() +
+                ": START GENERATE BG traffic... at time "+ GridSim.clock());
+        System.out.println(super.get_name() +
+                ": NEXT background traffic will start at " + time);
+        System.out.println(super.get_name() +
+                " num PACKETS = " + numPackets + ", freq = " + freq);
+        *********/
+
+        int i = 0;
+        int destId = -1;
+
+        // send to one of the entity using uniform distribution
+        if (pattern == TrafficGenerator.SEND_ONE_ONLY)
+        {
+            int index = random_.nextInt( list_.size() );
+            destId = ((Integer) list_.get(index)).intValue();
+
+            /*********   // DEBUG info
+            System.out.println(super.get_name() + ": Destination id = " +
+                destId + " = " + GridSim.getEntityName(destId) );
+            *********/
+
+            // create junk packets or empty FlowPacket.
+            for (i = 0; i < freq; i++) {
+                convertIntoPacket(MTU, numPackets+1, tag, destId, type);
+            }
+        }
+        // send to all resources + other entities
+        else if (pattern == TrafficGenerator.SEND_ALL)
+        {
+            // send to all resources and user entities
+            for (int k = 0; k < list_.size(); k++)
+            {
+                destId = ((Integer) list_.get(k)).intValue();
+
+                /*********   // DEBUG info
+                System.out.println(super.get_name() + ": Destination id = " +
+                    destId + " = " + GridSim.getEntityName(destId) );
+                *********/
+
+                // create junk packets or empty FlowPacket.
+                for (i = 0; i < freq; i++) {
+                    convertIntoPacket(MTU, numPackets+1, tag, destId, type);
+                }
+            }
+        }
+
+        // sends the next junk packets
+        super.sim_schedule(super.get_id(), time, GridSimTags.JUNK_PKT);
+    }
+
+    /**
+     * Initial start for the background traffic
+     * @pre $none
+     * @post $none
+     */
+    private synchronized void startBackgroundTraffic()
+    {
+        // if no background traffic generator, then skip the rest
+        if (gen_ == null) {
+            return;
+        }
+
+        // get the next inter-arrival time
+        long time = gen_.getNextPacketTime();
+        System.out.println(super.get_name() +
+                ": background traffic will start at time " + time);
+
+        // starts background traffic if the inter-arrival time is valid
+        if (time == -1) {
+            return;
+        }
+
+        super.sim_schedule(super.get_id(), time, GridSimTags.JUNK_PKT);
+    }
+
+    /**
+     * This method processes outgoing data without a network extension.
+     * @param ev        a Sim_event object
+     * @param gisID     the central/default GIS entity ID
+     * @param statID    the GridStatistic entity ID
+     * @param shutdownID    the GridSimShutdown entity ID
+     * @pre ev != null
+     * @post $none
+     */
+    private synchronized void defaultSend(Sim_event ev, int gisID, int statID,
+                int shutdownID)
+    {
+        IO_data io = (IO_data) ev.get_data();
+        int destId = io.getDestID();
+
+        /*****   // DEBUG info*/
+        System.out.println(super.get_name() + ".defaultSend(): Send to " +
+            GridSim.getEntityName(destId) + " tag = " + ev.get_tag() + " at time = " + GridSim.clock());
+        /*****/
+
+        // if this entity uses a network extension
+        if (link_ != null && destId != gisID && destId != statID &&
+            destId != shutdownID)
+        {
+        	System.out.println(super.get_name() + ".defaultSend(): submitToLink() + at time = " + GridSim.clock());
+            submitToLink(ev);
+            return;
+        }
+
+        // Identify ID of an entity which acts as Input/Buffer
+        // entity of destination entity
+        int id = GridSim.getEntityId( "Input_" +
+                 Sim_system.get_entity(destId).get_name() );
+
+        // Send first and then hold
+        super.sim_schedule(id, GridSimTags.SCHEDULE_NOW, ev.get_tag(), io);
+
+        double receiverBaudRate = ( (FlowBuffer)
+                Sim_system.get_entity(id) ).getBaudRate();
+
+        // NOTE: io is in byte and baud rate is in bits. 1 byte = 8 bits
+        // So, convert io into bits
+        double minBaudRate = Math.min(baudRate_, receiverBaudRate);
+        double communicationDelay = GridSimRandom.realIO(
+                (io.getByteSize() * BITS) / minBaudRate);
+
+        // NOTE: Below is a deprecated method for SimJava 2
+        //super.sim_hold(communicationDelay);
+        super.sim_process(communicationDelay);
+    }
+
+    /**
+     * This method takes data from an entity. If the size of the data is larger
+     * than the MTU of the link, then the packet is split into mutiple size
+     * units. After this it calls outEnque() to queue these packets into its
+     * buffer.
+     *
+     * @param ev    A Sim_event data that contains all the data for this method
+     *              to do its task.
+     * @pre ev != null
+     * @post $none
+     */
+    private synchronized void submitToLink(Sim_event ev)
+    {
+        IO_data data = (IO_data) ev.get_data();
+        Object obj = data.getData();
+        long size = data.getByteSize();
+        int tag = ev.get_tag();
+        int destId = data.getDestID();
+        int netServiceType = data.getNetServiceLevel();
+
+        // we need to packetsize the data, all packets are sent with size MTU.
+        // only the last packet contains the data, the receiver should
+        // throw away all other packets
+        //int MTU = link_.getMTU();
+        //int numPackets = (int) Math.ceil( size / (MTU * 1.0) );
+
+        // make dummy packets with null data
+        //System.out.println("Packetizing data, creating " + numPackets + " dummy packets at time = " + GridSim.clock());
+        //convertIntoPacket(MTU, numPackets, tag, destId, netServiceType);
+
+        // last packet contains the actual data
+        FlowPacket np = null;
+        np = new FlowPacket(obj,pktID_,size,tag,super.get_id(),
+                           destId, netServiceType, 1, 1);
+        
+        System.out.println("Sending flow packet to link at time = " + GridSim.clock() + " id is " + pktID_);
+        pktID_++;   // increments packet ID
+        outEnque(np, GridSimTags.SCHEDULE_NOW);
+    }
+
+    /**
+     * Creates many dummy or null packets
+     * @param size          packet size (in bytes)
+     * @param numPackets    total number of packets to be created
+     * @param tag           packet tag
+     * @param destId        destination ID for sending the packet
+     * @param netServiceType    level type of service for the packet
+     * @pre $none
+     * @post $none
+     */
+    private synchronized void convertIntoPacket(long size, int numPackets,
+                int tag, int destId, int netServiceType)
+    {
+        FlowPacket np = null;
+        for (int i = 0; i < numPackets - 1; i++)
+        {
+            // change the tag name for dummy packets, apart from junk packets
+            if (tag != GridSimTags.JUNK_PKT) {
+                tag = GridSimTags.EMPTY_PKT;
+            }
+
+            np = new FlowPacket(null, pktID_, size, tag, super.get_id(), destId,
+                               netServiceType, i+1, numPackets);
+
+            pktID_++;     // increments packet ID
+            outEnque(np, GridSimTags.SCHEDULE_NOW);
+        }
+    }
+
+    /**
+     * Sends an InfoPacket for ping request
+     * @param ev  a Sim_Event object
+     * @pre ev != null
+     * @post $none
+     */
+    private synchronized void sendInfoPacket(Sim_event ev)
+    {
+        IO_data data = (IO_data) ev.get_data();
+
+        // gets all the relevant info
+        long size = data.getByteSize();
+        int destId = data.getDestID();
+        int netServiceType = data.getNetServiceLevel();
+        int tag = ev.get_tag();
+        String name = GridSim.getEntityName( outPort_.get_dest() );
+
+        // we need to packetsize the data, all packets are sent with size MTU
+        // only the last packet contains the ping data, the receiver should
+        // throw away all other data
+        int MTU = link_.getMTU();
+        int numPackets = (int) Math.ceil( size / (MTU * 1.0) );
+
+        // break ping size into smaller pieces
+        // Also, make sure that it is not for pinging itself
+        if (size > MTU && outPort_.get_dest() != destId)
+        {
+            // make dummy packets with null data
+            convertIntoPacket(MTU, numPackets, tag, destId, netServiceType);
+        }
+
+        // get the remaining ping size
+        size = data.getByteSize() - MTU*(numPackets-1);
+
+        // create the real InfoPacket
+        InfoPacket pkt = new InfoPacket(name,pktID_,size,outPort_.get_dest(),
+                                        destId,netServiceType);
+
+        // set the required info
+        pkt.setLast( super.get_id() );
+        pkt.addHop( outPort_.get_dest() );
+        pkt.addEntryTime( GridSim.clock() );
+        pkt.setOriginalPingSize( data.getByteSize() );
+
+        pktID_++;   // increments packet ID
+        outEnque(pkt, GridSimTags.SCHEDULE_NOW);
+    }
+    
+    private synchronized void sendInfoPacket(int dest)
+    {
+  //      IO_data data = (IO_data) ev.get_data();
+
+        // gets all the relevant info
+        long size = 1500;
+        int destId = dest;
+// /       int netServiceType = data.getNetServiceLevel();
+ //       int tag = ev.get_tag();
+        String name = GridSim.getEntityName( outPort_.get_dest() );
+
+        // we need to packetsize the data, all packets are sent with size MTU
+        // only the last packet contains the ping data, the receiver should
+        // throw away all other data
+  //      int MTU = link_.getMTU();
+ //       int numPackets = (int) Math.ceil( size / (MTU * 1.0) );
+
+        // break ping size into smaller pieces
+        // Also, make sure that it is not for pinging itself
+        //if (size > MTU && outPort_.get_dest() != destId)
+        //{
+        //    // make dummy packets with null data
+        //    convertIntoPacket(MTU, numPackets, tag, destId, netServiceType);
+        //}
+
+        // get the remaining ping size
+        //size = data.getByteSize() - MTU*(numPackets-1);
+
+        // create the real InfoPacket
+        InfoPacket pkt = new InfoPacket(name,pktID_,size,outPort_.get_dest(),
+                                        destId,0);
+
+        // set the required info
+        pkt.setLast( super.get_id() );
+        pkt.addHop( outPort_.get_dest() );
+        pkt.addEntryTime( GridSim.clock() );
+        pkt.setOriginalPingSize( 1500 );
+        pkt.setTag(GridSimTags.INFOPKT_SUBMIT);
+
+        pktID_++;   // increments packet ID
+        outEnque(pkt, GridSimTags.SCHEDULE_NOW);
+    }
+
+    /**
+     * Sends back the ping() request to the next hop or destination
+     * @param ev  a Sim_event object
+     * @pre ev != null
+     * @post $none
+     */
+    private void returnInfoPacket(Sim_event ev)
+    {
+        IO_data data = (IO_data) ev.get_data();
+
+        // use the original ping size rather than IO_data or InfoPacket size
+        // since the latter is restricted to MTU
+        InfoPacket pkt = (InfoPacket) data.getData();
+        long size = pkt.getOriginalPingSize();
+
+        // get other relevant info
+        int tag = ev.get_tag();
+        int destId = pkt.getSrcID();
+        int netServiceType = data.getNetServiceLevel();
+
+        // we need to packetsize the data, all packets are sent with size MTU.
+        // only the last packet contains the data, the receiver should
+        // throw away all other packets
+        int MTU = link_.getMTU();
+        int numPackets = (int) Math.ceil( size / (MTU * 1.0) );
+
+        // make dummy packets with null data
+        convertIntoPacket(MTU, numPackets, tag, destId, netServiceType);
+
+        // set the original packet of last hop into this entity id
+        pkt.setLast( super.get_id() );
+        outEnque(pkt, GridSimTags.SCHEDULE_NOW);
+    }
+
+    /**
+     * Takes a packet, adds it into a buffer and schedules it to be sent out at
+     * an appropriate time.
+     *
+     * @param pkt   The packet to be buffered
+     * @param delay The length of time this packet should be delayed (exclusive
+     *              of the transmission time)
+     * @pre pkt != null
+     * @pre delay > 0
+     * @post $none
+     */
+    private synchronized void outEnque(Packet pkt, double delay)
+    {
+    	
+    	//if ((pkt instanceof InfoPacket) != true) {
+    	//	sendInfoPacket(pkt.getDestID());
+    	//}
+    		
+        outPacketList_.add(pkt);
+        if (outPacketList_.size() == 1)
+        {
+        	System.out.println(super.get_name() + ".outEnque() Size is " + pkt.getSize() + " baud " + link_.getBaudRate());
+            // Compute expected duration of flow using bottleneck baudRate
+        	// double total = delay + (pkt.getSize()*SIZE / link_.getBaudRate());
+        	double total = 0.0;
+            
+        	System.out.println(super.get_name() + ".outEnque() Time now " + GridSim.clock() + " delay is " + total);
+            super.sim_schedule(super.get_id(), total, GridSimTags.SEND_PACKET);
+        }
+        
+    	
+        
+
+    }
+    
+
+    /**
+     * Removes a single packet from the buffer and sends it down the link.
+     * Then, schedules the next packet in the list.
+     * @pre $none
+     * @post $none
+     */
+    private synchronized void sendPacket()
+    {
+        if (outPacketList_ == null || outPacketList_.isEmpty() == true) {
+            return;
+        }
+
+        // submits the first packet in the list
+        Packet np = (Packet) outPacketList_.remove(0);
+
+        boolean ping = false;   // a flag to determine ping packet or not
+        int tag = -1;       // event tag ID
+        int dest = -1;      // destination ID
+
+        // if a packet belongs to a ping packet
+        if (np instanceof InfoPacket)
+        {
+            ((InfoPacket)np).addExitTime( GridSim.clock() );
+            ((InfoPacket)np).addBaudRate( link_.getBaudRate() );
+            ping = true;
+            tag = GridSimTags.INFOPKT_SUBMIT;
+        }
+        
+        if (np instanceof FlowPacket && np.getTag() == GridSimTags.FLOW_SUBMIT ) {
+            ((FlowPacket)np).addBaudRate( link_.getBaudRate() );
+            ((FlowPacket)np).addLatency( link_.getDelay() );            
+        }
+        
+
+        // if an entity tries to send a packet to itself
+        if ( np.getDestID() == outPort_.get_dest() )
+        {
+            // then change the destination name and id
+            String destName = super.get_name();
+            destName = destName.replaceFirst("Output", "Input");
+            dest = Sim_system.get_entity_id(destName);
+
+            // for a ping packet, change the tag
+            if (ping == true)
+            {
+                // don't forget to change the packet tag
+                tag = GridSimTags.INFOPKT_RETURN;
+                ((InfoPacket) np).setTag(tag);
+            }
+            else {
+                tag = np.getTag();
+            }
+        }
+        else  // if an entity tries to send to other entity
+        {
+            // change or keep the event tag
+            tag = GridSimTags.PKT_FORWARD;
+            if (np.getTag() == GridSimTags.JUNK_PKT) {
+                tag = GridSimTags.JUNK_PKT;
+            }
+
+            // sends the packet into the link
+            dest = link_.get_id();
+        }
+
+        // send the packet
+        super.sim_schedule(dest, GridSimTags.SCHEDULE_NOW, tag, np);
+
+        /*****   // DEBUG info **/
+        System.out.println(super.get_name() + " send to " +
+                GridSim.getEntityName(dest) + " tag = " + tag + " time " + GridSim.clock());
+        /****/
+
+        // if the list is not empty, then schedule the next packet in the list
+        if (outPacketList_.isEmpty() != true)
+        {
+            //double delay = np.getSize() * SIZE / link_.getBaudRate();
+        	double delay = 0.0;
+            super.sim_schedule(super.get_id(), delay, GridSimTags.SEND_PACKET);
+        }
+    }
+    
+    private void getDataFromLink(Sim_event ev)
+    {
+        Object obj = ev.get_data();
+        double duration = 0.0;
+        
+        if (obj instanceof Packet)
+        {
+            // decrypt the packet into original format
+            Packet pkt = (Packet) ev.get_data();
+
+            if (pkt instanceof InfoPacket)
+            {
+                processPingRequest( (InfoPacket) pkt);
+                return;
+            }
+
+            // all except last packet in a data session are null packets
+            if (pkt instanceof FlowPacket)
+            {
+                FlowPacket np = (FlowPacket) pkt;
+                int tag = np.getTag();
+                System.out.println("Packet id is " + np.getID());
+
+                // ignore incoming junk packets
+                if (tag == GridSimTags.JUNK_PKT) {
+                    return;
+                }
+
+                // ignore incoming null dummy packets
+                if (tag == GridSimTags.EMPTY_PKT && np.getData() == null) {
+                    return;
+                }
+
+                // convert the packets into IO_data
+                Object data = np.getData();
+                IO_data io = new IO_data( data, np.getSize(),
+                		                  outPort_.get_src());
+                System.out.println(super.get_name() + ".getDataFromLink() Time now " + GridSim.clock() 
+                		+ " bottleneck was " + np.getBandwidth_() + " sum lat is " + np.getLatency() );
+                
+                // if flow terminates at next entity, add to active flows 
+                // & hold for appropriate duration
+                if (pkt.getTag() == GridSimTags.FLOW_SUBMIT) {
+                   duration = np.getSize()*SIZE / np.getBandwidth_();
+                   activeFlows_.put(pkt.getID(), pkt);
+                   super.sim_schedule(super.get_id(), duration, GridSimTags.FLOW_HOLD, new Integer(pkt.getID()));
+                   
+                // if flow is just an ACK of a finished flow do not hold    
+                } else if (pkt.getTag() == GridSimTags.FLOW_RETURN){              	
+                	duration = 0.0;
+                    // send the data into entity input port
+                    super.sim_schedule(outPort_, duration, tag,
+                                     io.getData() );
+                }
+
+
+            }
+        }
+    }
+    
+    private void processPingRequest(InfoPacket pkt)
+    {
+        // add more information to ping() packet
+        pkt.addHop( outPort_.get_dest() );
+        pkt.addEntryTime( GridSim.clock() );
+
+        IO_data io = new IO_data( pkt, pkt.getSize(), outPort_.get_dest() );
+
+        // send this ping() packet to the entity
+        super.sim_schedule(outPort_, GridSimTags.SCHEDULE_NOW,
+                           pkt.getTag(), io.getData());
+    }
+
+} // end class
+


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




Thread: [Gridsim-commits] SF.net SVN: gridsim: [112] branches/gridsim4.0-branch2/source/gridsim/net/ flow/F

gridsim-commits