/**     * Determines the smallest completion time of all Gridlets in the execution     * list. The smallest time is used as an internal event to     * update Gridlets processing in the future.     * <p>     * The algorithm for this method:     * <ul>     *     <li> identify the finish time for each Gridlet in the execution list     *          given the share MIPS rating for all and the remaining Gridlet's     *          length     *     <li> find the smallest finish time in the list     *     <li> send the last Gridlet in the list with     *          <tt>delay =  smallest finish time - current time</tt>     * </ul>     * @pre $none     * @post $none     */    private void forecastGridlet()    {        // if no Gridlets available in exec list, then exit this method        if (gridletInExecList_.size() == 0) {            return;        }        // checks whether Gridlets have finished or not. If yes, then remove        // them since they will effect the MIShare calculation.        checkGridletCompletion();        // Identify MIPS share for all Gridlets for 1 second, considering        // current Gridlets + No of PEs.        MIShares share = getMIShare( 1.0, gridletInExecList_.size() );        ResGridlet rgl = null;        int i = 0;        double time = 0.0;        double rating = 0.0;        double smallestTime = 0.0;        // For each Gridlet, determines their finish time        Iterator iter = gridletInExecList_.iterator();        while ( iter.hasNext() )        {            rgl = (ResGridlet) iter.next();            // If a Gridlet locates before the max count then it will be given            // the max. MIPS rating            if (i < share.maxCount) {                rating = share.max;            }            else {   // otherwise, it will be given the min. MIPS Rating                rating = share.min;            }            time = forecastFinishTime(rating, rgl.getRemainingGridletLength() );            int roundUpTime = (int) (time+1);   // rounding up            rgl.setFinishTime(roundUpTime);            // get the smallest time of all Gridlets            if (i == 0 || smallestTime > time) {                smallestTime = time;            }            i++;        }        // sends to itself as an internal event        super.sendInternalEvent(smallestTime);    }    /**     * Checks all Gridlets in the execution list whether they are finished or     * not.     * @pre $none     * @post $none     */    private void checkGridletCompletion()    {        ResGridlet rgl = null;        // a loop that determine the smallest finish time of a Gridlet        // Don't use an iterator since it causes an exception because if        // a Gridlet is finished, gridletFinish() will remove it from the list.        int i = 0;        while ( i < gridletInExecList_.size() )        {            rgl = (ResGridlet) gridletInExecList_.get(i);            // if a Gridlet has finished, then remove it from the list            if (rgl.getRemainingGridletLength() <= 0.0)            {                gridletFinish(rgl, Gridlet.SUCCESS);                continue;  // not increment i coz the list size also decreases            }            i++;        }    }    /**     * Forecast finish time of a Gridlet.     * <tt>Finish time = length / available rating</tt>     * @param availableRating   the shared MIPS rating for all Gridlets     * @param length   remaining Gridlet length     * @return Gridlet's finish time.     */    private double forecastFinishTime(double availableRating, double length)    {        double finishTime = length / availableRating;        // This is as a safeguard since the finish time can be extremely        // small close to 0.0, such as 4.5474735088646414E-14. Hence causing        // some Gridlets never to be finished and consequently hang the program        if (finishTime < 1.0) {            finishTime = 1.0;        }        return finishTime;    }    /**     * Updates the Gridlet's properties, such as status once a     * Gridlet is considered finished.     * @param rgl     a ResGridlet object     * @param status  the status of this ResGridlet object     * @pre rgl != null     * @post $none     */    private void gridletFinish(ResGridlet rgl, int status)    {        // NOTE: the order is important! Set the status first then finalize        // due to timing issues in ResGridlet class.        rgl.setGridletStatus(status);        rgl.finalizeGridlet();        // sends back the Gridlet with no delay        Gridlet gl = rgl.getGridlet();        super.sendFinishGridlet(gl);        // remove this Gridlet in the execution        gridletInExecList_.remove(rgl);    }    /**     * Handles internal event     * @pre $none     * @post $none     */    private void internalEvent()    {        // this is a constraint that prevents an infinite loop        // Compare between 2 floating point numbers. This might be incorrect        // for some hardware platform.        if ( lastUpdateTime_ == GridSim.clock() ) {            return;        }        // update Gridlets in execution up to this point in time        updateGridletProcessing();        // schedule next event        forecastGridlet();    }    /**     * Handles an operation of canceling a Gridlet in either execution list     * or paused list.     * @param gridletId    a Gridlet ID     * @param userId       the user or owner's ID of this Gridlet     * @param an object of ResGridlet or <tt>null</tt> if this Gridlet is not     *        found     * @pre gridletId > 0     * @pre userId > 0     * @post $none     */    private ResGridlet cancel(int gridletId, int userId)    {        ResGridlet rgl = null;        // Check whether the Gridlet is in execution list or not        int found = super.findGridlet(gridletInExecList_, gridletId, userId);        // if a Gridlet is in execution list        if (found >= 0)        {            // update the gridlets in execution list up to this point in time            updateGridletProcessing();            // Get the Gridlet from the execution list            rgl = (ResGridlet) gridletInExecList_.remove(found);            // if a Gridlet is finished upon cancelling, then set it to success            if (rgl.getRemainingGridletLength() == 0.0) {                rgl.setGridletStatus(Gridlet.SUCCESS);            }            else {                rgl.setGridletStatus(Gridlet.CANCELED);            }            // then forecast the next Gridlet to complete            forecastGridlet();        }        // if a Gridlet is not in exec list, then find it in the paused list        else        {            found = super.findGridlet(gridletPausedList_, gridletId, userId);            // if a Gridlet is found in the paused list then remove it            if (found >= 0)            {                rgl = (ResGridlet) gridletPausedList_.remove(found);                rgl.setGridletStatus(Gridlet.CANCELED);            }        }        return rgl;    }    /**     * Sets the status of all Gridlets in this resource to <tt>FAILED</tt>.     * Then sends them back to users, and clean up the relevant lists.     */    public void setGridletsFailed()    {        ResGridlet rgl;        int gridletPausedList_size = gridletPausedList_.size();        int gridletInExecList_size = gridletInExecList_.size();        /*******************        // Uncomment this to get more info on the progress of sims        System.out.println("################# " + super.get_name() +        ". Cleaning gridlets in InExec and Paused lists in the failed resource." +        " gridletInExecList_.size (): " + gridletInExecList_.size() +        " gridletPausedList_.size (): " + gridletPausedList_.size());        *******************/        for (int i = 0; i<gridletPausedList_size; i++)        {            rgl = (ResGridlet) gridletPausedList_.get(0);            int status = rgl.getGridletStatus();            // if the gridlet has already finished, then just send it back.            // Otherwise, set status to FAILED_RESOURCE_UNAVAILABLE            if (status != Gridlet.SUCCESS)            {                rgl.setGridletStatus(Gridlet.FAILED_RESOURCE_UNAVAILABLE);            }            rgl.finalizeGridlet();            super.sendFinishGridlet(rgl.getGridlet());            gridletPausedList_.remove(0);        }        updateGridletProcessing();        // go on with the gridlet in exec list.        for (int i = 0; i < gridletInExecList_size; i++)        {            rgl = (ResGridlet) gridletInExecList_.get(0);            int status = rgl.getGridletStatus();            // if the gridlet has already finished, then just send it back.            // Otherwise, set status to FAILED_RESOURCE_UNAVAILABLE            if (status != Gridlet.SUCCESS)            {                rgl.setGridletStatus(Gridlet.FAILED_RESOURCE_UNAVAILABLE);            }            rgl.finalizeGridlet();            super.sendFinishGridlet(rgl.getGridlet());            gridletInExecList_.remove(0);        }    }    /**     * This method is empty because it is not required by this policy.     * Sets the status of all Gridlets in this machine to <tt>FAILED</tt>.     * Then sends them back to users, and clean up the relevant lists.     * @param failedMachID  the id of the failed machine     */    public void setGridletsFailed(int failedMachID)    {        // Nothing, as in a time_shared machine, all the gridlets use the        // machine in turn, during a period of time.        // So, gridlets are not allocated tightly to a machine or PE.        // Because of that, we don't have to make fail any gridlet        // when a machine fails    }} // end class