/* * 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: Agustin Caminero * Organization: Universidad de Castilla La Mancha (UCLM), Spain. * Created on: Nov 2006. */package gridsim.resFailure;import gridsim.*;import java.util.Iterator;import eduni.simjava.Sim_event;import eduni.simjava.Sim_system;import gridsim.ResGridletList;import gridsim.GridSim;import gridsim.Gridlet;/** * SpaceSharedWithFailure class is based on {@link gridsim.SpaceShared}, but * with added failure functionalities. * SpaceSharedWithFailure class is an allocation policy for GridResource that * behaves exactly like First Come First Serve (FCFS). This is a basic and * simple scheduler that runs each Gridlet to one Processing Element (PE). * If a Gridlet requires more than one PE, then this scheduler only assign * this Gridlet to one PE. * * @author       Agustin Caminero * @since        GridSim Toolkit 4.1 * @see gridsim.SpaceShared * @invariant $none */class SpaceSharedWithFailure extends AllocPolicy implements AllocPolicyWithFailure{    private ResGridletList gridletQueueList_;     // Queue list    private ResGridletList gridletInExecList_;    // Execution list    private ResGridletList gridletPausedList_;    // Pause list    private double lastUpdateTime_;    // the last time Gridlets updated    private int[] machineRating_;      // list of machine ratings available    /**     * Allocates a new SpaceSharedWithFailure object     * @param resourceName    the GridResource entity name that will contain     *                        this allocation policy     * @param entityName      this object entity name     * @throws Exception This happens when one of the following scenarios occur:     *      <ul>     *          <li> creating this entity before initializing GridSim package     *          <li> this entity name is <tt>null</tt> or empty     *          <li> this entity has <tt>zero</tt> number of PEs (Processing     *              Elements). <br>     *              No PEs mean the Gridlets can't be processed.     *              A GridResource must contain one or more Machines.     *              A Machine must contain one or more PEs.     *      </ul>     * @see gridsim.GridSim#init(int, Calendar, boolean, String[], String[],     *          String)     * @pre resourceName != null     * @pre entityName != null     * @post $none     */    SpaceSharedWithFailure(String resourceName, String entityName) throws Exception    {        super(resourceName, entityName);        // initialises local data structure        this.gridletInExecList_ = new ResGridletList();        this.gridletPausedList_ = new ResGridletList();        this.gridletQueueList_  = new ResGridletList();        this.lastUpdateTime_ = 0.0;        this.machineRating_ = null;    }    /**     * Handles internal events that are coming to this entity.     * @pre $none     * @post $none     */    public void body()    {        // Gets the PE's rating for each Machine in the list.        // Assumed one Machine has same PE rating.        MachineList list = super.resource_.getMachineList();        int size = list.size();        machineRating_ = new int[size];        for (int i = 0; i < size; i++) {            machineRating_[i] = super.resource_.getMIPSRatingOfOnePE(i, 0);        }        // a loop that is looking for internal events only        Sim_event ev = new Sim_event();        while ( Sim_system.running() )        {            super.sim_get_next(ev);            // if the simulation finishes then exit the loop            if (ev.get_tag() == GridSimTags.END_OF_SIMULATION ||                super.isEndSimulation() == true)            {                break;            }            // Internal Event if the event source is this entity            if (ev.get_src() == super.myId_ && gridletInExecList_.size() > 0)            {                updateGridletProcessing();   // update Gridlets                checkGridletCompletion();    // check for finished Gridlets            }        }        // CHECK for ANY INTERNAL EVENTS WAITING TO BE PROCESSED        while (super.sim_waiting() > 0)        {            // wait for event and ignore since it is likely to be related to            // internal event scheduled to update Gridlets processing            super.sim_get_next(ev);            System.out.println(super.resName_ +                    ".SpaceSharedWithFailure.body(): ignore internal events");        }    }    /**     * Schedules a new Gridlet that has been received by the GridResource     * entity.     * @param   gl    a Gridlet object that is going to be executed     * @param   ack   an acknowledgement, i.e. <tt>true</tt> if wanted to know     *        whether this operation is success or not, <tt>false</tt>     *        otherwise (don't care)     * @pre gl != null     * @post $none     */    public void gridletSubmit(Gridlet gl, boolean ack)    {        // update the current Gridlets in exec list up to this point in time        updateGridletProcessing();        // reset number of PE since at the moment, it is not supported        if (gl.getNumPE() > 1)        {            String userName = GridSim.getEntityName( gl.getUserID() );            System.out.println();            System.out.println(super.get_name() + ".gridletSubmit(): " +                " Gridlet #" + gl.getGridletID() + " from " + userName +                " user requires " + gl.getNumPE() + " PEs.");            System.out.println("--> Process this Gridlet to 1 PE only.");            System.out.println();            // also adjusted the length because the number of PEs are reduced            int numPE = gl.getNumPE();            double len = gl.getGridletLength();            gl.setGridletLength(len*numPE);            gl.setNumPE(1);        }        ResGridlet rgl = new ResGridlet(gl);        boolean success = false;        // if there is an available PE slot, then allocate immediately        if (gridletInExecList_.size() < super.totalPE_) {            success = allocatePEtoGridlet(rgl);        }        // if no available PE then put the ResGridlet into a Queue list        if (success == false)        {            rgl.setGridletStatus(Gridlet.QUEUED);            gridletQueueList_.add(rgl);        }        // sends back an ack if required        if (ack == true)        {            super.sendAck(GridSimTags.GRIDLET_SUBMIT_ACK, true,                          gl.getGridletID(), gl.getUserID()            );        }    }    /**     * Finds the status of a specified Gridlet ID.     * @param gridletId    a Gridlet ID     * @param userId       the user or owner's ID of this Gridlet     * @return the Gridlet status or <tt>-1</tt> if not found     * @see gridsim.Gridlet     * @pre gridletId > 0     * @pre userId > 0     * @post $none     */    public int gridletStatus(int gridletId,int userId)    {        ResGridlet rgl = null;        // Find in EXEC List first        int found = super.findGridlet(gridletInExecList_, gridletId, userId);        if (found >= 0)        {            // Get the Gridlet from the execution list            rgl = (ResGridlet) gridletInExecList_.get(found);            return rgl.getGridletStatus();        }        // Find in Paused List        found = super.findGridlet(gridletPausedList_, gridletId, userId);        if (found >= 0)        {            // Get the Gridlet from the execution list            rgl = (ResGridlet) gridletPausedList_.get(found);            return rgl.getGridletStatus();        }        // Find in Queue List        found = super.findGridlet(gridletQueueList_, gridletId, userId);        if (found >= 0)        {            // Get the Gridlet from the execution list            rgl = (ResGridlet) gridletQueueList_.get(found);            return rgl.getGridletStatus();        }        // if not found in all 3 lists then no found        return -1;    }    /**     * Cancels a Gridlet running in this entity.     * This method will search the execution, queued and paused list.     * The User ID is     * important as many users might have the same Gridlet ID in the lists.     * <b>NOTE:</b>     * <ul>     *    <li> Before canceling a Gridlet, this method updates all the     *         Gridlets in the execution list. If the Gridlet has no more MIs     *         to be executed, then it is considered to be <tt>finished</tt>.     *         Hence, the Gridlet can't be canceled.     *     *    <li> Once a Gridlet has been canceled, it can't be resumed to     *         execute again since this method will pass the Gridlet back to     *         sender, i.e. the <tt>userId</tt>.     *     *    <li> If a Gridlet can't be found in both execution and paused list,     *         then a <tt>null</tt> Gridlet will be send back to sender,     *         i.e. the <tt>userId</tt>.     * </ul>     *     * @param gridletId    a Gridlet ID     * @param userId       the user or owner's ID of this Gridlet     * @pre gridletId > 0     * @pre userId > 0     * @post $none     */    public void gridletCancel(int gridletId, int userId)    {        // cancels a Gridlet        ResGridlet rgl = cancel(gridletId, userId);        // if the Gridlet is not found        if (rgl == null)        {            System.out.println(super.resName_ +                    ".SpaceSharedWithFailure.gridletCancel(): Cannot find " +                    "Gridlet #" + gridletId + " for User #" + userId);            super.sendCancelGridlet(GridSimTags.GRIDLET_CANCEL, null,                                    gridletId, userId);            return;        }        // if the Gridlet has finished beforehand then prints an error msg        if (rgl.getGridletStatus() == Gridlet.SUCCESS)        {            System.out.println(super.resName_                    + ".SpaceSharedWithFailure.gridletCancel(): Cannot cancel"                    + " Gridlet #" + gridletId + " for User #" + userId                    + " since it has FINISHED.");        }        // sends the Gridlet back to sender        rgl.finalizeGridlet();        super.sendCancelGridlet(GridSimTags.GRIDLET_CANCEL, rgl.getGridlet(),                                gridletId, userId);    }    /**     * Pauses a Gridlet only if it is currently executing.     * This method will search in the execution list. The User ID is     * important as many users might have the same Gridlet ID in the lists.     * @param gridletId    a Gridlet ID     * @param userId       the user or owner's ID of this Gridlet     * @param   ack   an acknowledgement, i.e. <tt>true</tt> if wanted to know     *        whether this operation is success or not, <tt>false</tt>     *        otherwise (don't care)     * @pre gridletId > 0     * @pre userId > 0     * @post $none     */    public void gridletPause(int gridletId, int userId, boolean ack)    {        boolean status = false;