/* * Title:        GridSim Toolkit * Description:  GridSim (Grid Simulation) Toolkit for Modeling and Simulation *               of Parallel and Distributed Systems such as Clusters and Grids *               An example of how to use the failure functionality. * Licence:      GPL - http://www.gnu.org/copyleft/gpl.html * * Author: Agustin Caminero and Anthony Sulistio * Organization: UCLM (Spain) * Created on: August 2007 */import gridsim.*;import gridsim.index.AbstractGIS;import gridsim.net.Link;import java.util.Random;import java.util.ArrayList;import java.io.FileWriter;import gridsim.resFailure.RegionalGISWithFailure;import eduni.simjava.Sim_system;import eduni.simjava.Sim_event;/** * Creates a Grid User that also considers what happens if a resource fails. * @author       Agustin Caminero and Anthony Sulistio * @since        GridSim Toolkit 4.1 */public class GridUserFailureEx01 extends GridUser{    // the base for our constants (chosen at random)    private static final int BASE = 440000;    /** This constant is to tell the user when he should submit a gridlet */    private static final int SUBMIT_GRIDLET = BASE + 1;    private ArrayList GridletSubmittedList_;   // list of submitted Gridlets    private GridletList GridletReceiveList_;   // list of received Gridlets    private int NUM_GRIDLETS;    private double pollingTime_;    // The sizes of gridlets    private int gridletLength;    private int gridletInput;    private int gridletOutput;    // we keep here the time when each gridlet is submitted    private double gridletSubmissionTime [];    private double gridletLatencyTime [];    // a flag that denotes whether to trace GridSim events or not.    private boolean trace_flag;    /**     * Creates a GridUserFailure object     * @param name      this entity name     * @param link      a network link connecting this entity     * @param pollTime  the time between polls     * @param glLength  length (MI) for the gridlets of this user     * @param glIn      input file size for the gridlets of this user     * @param glOut     output file size for the gridlets of this user     * @param trace_flag  a flag that denotes whether to trace this user events     *                    or not.     * @throws java.lang.Exception happens if either name or link is empty     */    public GridUserFailureEx01(String name, Link link, double pollTime,                        int glLength, int glIn, int glOut, boolean trace_flag)                        throws Exception    {        super(name, link);        this.GridletSubmittedList_ = new ArrayList();        this.GridletReceiveList_ = new GridletList();        pollingTime_ = pollTime;        gridletLength = glLength;        gridletInput = glIn;        gridletOutput = glOut;        this.trace_flag = trace_flag;    }    /**     * Sets the number of gridlets that this user has to submit.     * Also, create the submission and reception  times arrays.     * @param gridlet_num the number of gridlets     */    public void setGridletNumber(int gridlet_num)    {        NUM_GRIDLETS = gridlet_num;        gridletSubmissionTime = new double[NUM_GRIDLETS];        gridletLatencyTime = new double[NUM_GRIDLETS];    }    /**     * Handles incoming requests to this entity.     * This method specifies the behaviours and/or scenarios of a user.     */    public void body()    {        initializeResultsFile();        createGridlet(super.get_id(), NUM_GRIDLETS);        // schedule the initial sending of gridlets.        // The sending will start in a ramdom time within 5 min        Random random = new Random();        int init_time = random.nextInt(5*60);        // sends a reminder to itself        super.send(super.get_id(), init_time, SUBMIT_GRIDLET);        System.out.println(super.get_name() +               ": initial SUBMIT_GRIDLET event will be at clock: " +               init_time + ". Current clock: " + GridSim.clock());        ////////////////////////////////////////////////////////////        // Now, we have the framework of the entity:        while (Sim_system.running())        {            Sim_event ev = new Sim_event();            super.sim_get_next(ev); // get the next event in the queue            switch (ev.get_tag())            {                // submit a gridlet                case SUBMIT_GRIDLET:                    processGridletSubmission(ev); // process the received event                    break;                // Receive a gridlet back                case GridSimTags.GRIDLET_RETURN:                    processGridletReturn(ev);                    break;                case GridSimTags.END_OF_SIMULATION:                    System.out.println("\n============== " + super.get_name() +                                       ". Ending simulation...");                    break;                default:                    System.out.println(super.get_name() +                                       ": Received an event: " + ev.get_tag());                    break;            } // switch        } //  while        // remove I/O entities created during construction of this entity        super.terminateIOEntities();        // prints the completed gridlets        printGridletList(GridletReceiveList_, super.get_name(), false,                         gridletLatencyTime);    } // body()    /////////////////////////////////////////////////////////////////////////    /**     * This functions process the submission  of a gridlet. We have to get the     * list of available resources from the RegGIS, choose one of them, and     * submit the gridlet.     * @param ev an incoming event     */    private void processGridletSubmission(Sim_event ev)    {        if (trace_flag)        {            System.out.println(super.get_name() +                ": received an SUBMIT_GRIDLET event. Clock: " + GridSim.clock());        }        /***********        We have to submit:             - the gridlet whose id comes with the event             - all the gridlets with the "gridletSub.getSubmitted() == false"        So, set the gridletSub.getSubmitted() to false for the gridlet whose        id comes with the event        ***********/        int i = 0;        GridletSubmission gridletSub;        int resourceID[];        Random random = new Random(5);   // a random generator with a random seed        int index;        Gridlet gl;        Integer obj;        int glID;        // This is because the initial GRIDLET_SUBMIT event, at the beginning        // of sims, does not have any gridlet id. We have to submit        // all the gridlets.        if (ev.get_data() instanceof Integer)        {            obj = (Integer) ev.get_data();            glID = obj.intValue(); // get the gridlet id.        }        else {            glID = 99; // a value at random, not used at all in this case        }        while (i < GridletSubmittedList_.size())        {            gridletSub = (GridletSubmission)GridletSubmittedList_.get(i);            if ( (gridletSub.getGridlet()).getGridletID() == glID )            {                // set this gridlet whose id comes with the event as not submitted,                // so that it is submitted as soon as possible.                ((GridletSubmission) GridletSubmittedList_.get(i)).setSubmitted(false);            }            // Submit the gridlets with the "gridletSub.getSubmitted() == false"            if ( (gridletSub.getSubmitted() == false))            {                // we have to resubmit this gridlet                gl = ((GridletSubmission) GridletSubmittedList_.get(i)).getGridlet();                resourceID = getResList(); // Get list of resources from GIS                // If we have resources in the list                if ((resourceID != null) && (resourceID.length != 0))                {                    index = random.nextInt(resourceID.length);                    // make sure the gridlet will be executed from the begining                    resetGridlet(gl);                    // submits this gridlet to a resource                    super.gridletSubmit(gl, resourceID[index]);                    gridletSubmissionTime[gl.getGridletID()] = GridSim.clock();                    // set this gridlet as submitted                    ((GridletSubmission) GridletSubmittedList_.get(i)).setSubmitted(true);                    if (trace_flag)                    {                        System.out.println(super.get_name() +                               ": Sending Gridlet #" + i + " to " +                               GridSim.getEntityName(resourceID[index]) +                               " at clock: " + GridSim.clock());                        // Write into a results file                        write(super.get_name(), "Sending", gl.getGridletID(),                              GridSim.getEntityName(resourceID[index]),                              gl.getGridletStatusString(), GridSim.clock());                    }                }                // No resources available at this moment, so schedule an event                // in the future. The event wil be in 15 min (900 sec), as                // resource failures may last several hours.                // This event includes the gridletID, so that the user will                // try to submit only this gridlet                else                {                    super.send(super.get_id(), GridSimTags.SCHEDULE_NOW + 900,                               SUBMIT_GRIDLET, new Integer(gl.getGridletID()) );                }            }// if (gridletSub.getSubmitted() == false)            i++;        } // while (i < GridletSubmittedList_.size())    } // processGridletSubmission    /**     * This functions process the return of a gridlet.     * We pay attention to the status of the gridlet     * and then decide what we have to do the next     * @param ev an incoming event     */    private void processGridletReturn(Sim_event ev)    {        if (trace_flag)        {            System.out.println(super.get_name() +                ": received an GRIDLET_RETURN event. Clock: " + GridSim.clock());        }        Object obj = (Object) ev.get_data();        Gridlet gl = null;        Random random = new Random(5);   // a random generator with a random seed        if (obj instanceof Gridlet)        {            gl = (Gridlet) obj;            gridletLatencyTime[gl.getGridletID()] = GridSim.clock();            // Write into a results file            if (trace_flag)            {                write(super.get_name(), "Receiving", gl.getGridletID(),                      GridSim.getEntityName(gl.getResourceID()),                      gl.getGridletStatusString(), GridSim.clock());            }            ///////////////////////// Gridlet Success            if (gl.getGridletStatusString().compareTo("Success") == 0)            {                System.out.println(super.get_name() + ": Receiving Gridlet #" +                       gl.getGridletID() + " with status Success at time = " +                       GridSim.clock() + " from resource " +                       GridSim.getEntityName(gl.getResourceID()));                this.GridletReceiveList_.add(gl); // add into the received list                gridletLatencyTime[gl.getGridletID()] =                        gridletLatencyTime[gl.getGridletID()] -                        gridletSubmissionTime[gl.getGridletID()];                // We have received all the gridlets. So, finish the simulation.                if (GridletReceiveList_.size() == GridletSubmittedList_.size())                {                    super.finishSimulation();                }            } // if (gl.getGridletStatusString() == "Success")            //////////////////////// Gridlet Failed            else if (gl.getGridletStatusString().compareTo("Failed") == 0)            {                System.out.println(super.get_name() + ": Receiving Gridlet #" +                       gl.getGridletID() + " with status Failed at time = " +                       GridSim.clock() + " from resource " +                       GridSim.getEntityName(gl.getResourceID()));                // Send the gridlet as soon as we have resources available.                // This gridlet will be resend as soon as possible,                // in the first loop.                int pos = findGridletInGridletSubmittedList(gl);                if (pos == -1) {                    System.out.println(super.get_name() +                        ". Gridlet not found in GridletSubmittedList.");                }                else                {                    // set this gridlet as submitted, because otherwise                    // this gridlet may be submitted several times.                    // A gridlet will only be submitted when the event carrying                    // its id reaches the user                    ((GridletSubmission) GridletSubmittedList_.get(pos)).setSubmitted(true);                    // Now, schedule an event to itself to submit the gridlet                    // The gridlet will be sent as soon as possible                    Integer glID_Int = new Integer(gl.getGridletID());                    // This event includes the gridletID, so that the user                    // will try to submit only this gridlet                    super.send(super.get_id(), GridSimTags.SCHEDULE_NOW,                               SUBMIT_GRIDLET, glID_Int);                }            } // if (gl.getGridletStatusString() == "Failed")            ////////////////////////////// Gridlet Failed_resource            else if (gl.getGridletStatusString().compareTo("Failed_resource_unavailable") == 0)            {                int pos = findGridletInGridletSubmittedList(gl);                if (pos == -1) {                    System.out.println(super.get_name() +                        ". Gridlet not found in GridletSubmittedList.");                }                else                {                    // Now, set its submission time for a random time between                    // 1 and the polling time                    double resubmissionTime = random.nextDouble() * pollingTime_;                    // this is to prevent the gridlet from being submitted                    // before its resubmission time.                    // This is different from the FAILED case, because