source: gssim/trunk/src/test/guiexp/MixedAllSlots.java @ 13

package test.guiexp;



import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import org.joda.time.DateTime;

import schedframe.exceptions.ReservationException;
import schedframe.resources.providers.LocalSystem;
import schedframe.resources.units.Processors;
import schedframe.scheduling.AbstractResourceRequirements;
import schedframe.scheduling.AbstractTimeRequirements;
import schedframe.scheduling.Offer;
import schedframe.scheduling.Queue;
import schedframe.scheduling.Reservation;
import schedframe.scheduling.ReservationList;
import schedframe.scheduling.ResourceUsage;
import schedframe.scheduling.TaskInterface;
import schedframe.scheduling.TimeResourceAllocation;
import schedframe.scheduling.events.ReservationActiveEvent;
import schedframe.scheduling.events.SchedulingEvent;
import schedframe.scheduling.events.SchedulingEventType;
import schedframe.scheduling.events.StartTaskExecutionEvent;
import schedframe.scheduling.plugin.SchedulingPluginConfiguration;
import schedframe.scheduling.plugin.configuration.DefaultConfiguration;
import schedframe.scheduling.plugin.local.LocalReservationManager;
import schedframe.scheduling.plugin.local.ResourceUnitsManagerInterface;
import example.localplugin.BaseLocalARPlugin;
import gridsim.Gridlet;
import gridsim.gssim.ResourceUnitsManagerImpl;
import gridsim.gssim.SubmittedTask;
import gssim.schedframe.scheduling.plugin.local.LocalReservationManagerImpl;

/**
 * 
 * @author Marcin Krystek
 * @author Wojciech Piatek
 * 
 *
 */
public class MixedAllSlots extends BaseLocalARPlugin {

        /*
         * This implementation of getOffers() method returns detail state of the resource in
         * requested time. Imagine the result as a gantt diagram of resource usage between
         * start and end time.
         * Grid scheduling plugin must analyze this result, decide if there are enough 
         * resource units and create reservation of this units.
         */
        public List<Offer> getOffers(AbstractTimeRequirements<?> timeReqs,
                        AbstractResourceRequirements<?> resReqs,
                        List<? extends TaskInterface<?>> inExecution,
                        List<Queue<? extends TaskInterface<?>>> queues,
                        ResourceUnitsManagerInterface unitsManagerInterface,
                        LocalReservationManager reservManager)
                        throws ReservationException {

                LocalReservationManagerImpl reservationManager = (LocalReservationManagerImpl) reservManager;
                ResourceUnitsManagerImpl unitsManager = (ResourceUnitsManagerImpl) unitsManagerInterface;
                
                List<TimeResourceAllocation> usageList = null;
                int reqCpuCnt = 0;
                
                try {

                        // get number of processors requested by the task
                        reqCpuCnt = Double.valueOf(resReqs.getCpuCntRequest()).intValue();
                
                        // create unit for which resource usage will be created
                        Processors processors = new Processors(unitsManager.getResourceName(), unitsManager.getNumPE(), reqCpuCnt);

                        DateTime startTime = timeReqs.getStart();
                        DateTime endTime = timeReqs.getEnd();

                        // get resource usage
                        usageList = reservationManager.resourceUsageList(processors, inExecution, startTime, endTime);
                        
                } catch (NoSuchFieldException e) {
                        e.printStackTrace();
                        return null;
                }
                
                // prepare offer
                LocalSystem provider = new LocalSystem(unitsManager.getResourceName(), null, null);
                Offer offer = new Offer();
                offer.setProvider(provider);

                for(int i = 0; i < usageList.size(); i++){
                        offer.add(usageList.get(i));
                }
                List<Offer> list = new ArrayList<Offer>(1);
                list.add(offer);
                
                return list;
        }

        public String getPluginName() {
                return getClass().getName();
        }

        public void initPlugin(Properties properties) {
                getConfiguration().getServedEvents().put(SchedulingEventType.TASK_ARRIVED, null);
                // TODO Auto-generated constructor stub
        }
        
        public Reservation commitReservation(Reservation initialReservation,
                        List<? extends TaskInterface<?>> inExecution,
                        List<Queue<? extends TaskInterface<?>>> queues,
                        ResourceUnitsManagerInterface unitsManager,
                        LocalReservationManager reservationManager)
                        throws ReservationException {
                
                // this simple implementation changes status of the reservation
                // from INITIAL to COMMITED
                
                // list of reservations is managed by reservation manager
                List<Reservation> list = reservationManager.getReservations();
                
                for(int i = 0; i < list.size(); i++){
                        Reservation r = list.get(i);

                        // find correct reservation in reservations list
                        if(initialReservation.getId().equals(r.getId())){
                        
                                // change status to COMMITED
                                r.setStatus(Reservation.Status.COMMITTED);
                                
                                // set job and task id on behalf which this reservation is 
                                // created. This is mostly for debugging purpose.
                                r.setJobId(initialReservation.getJobId());
                                r.setTaskId(initialReservation.getTaskId());
                                
                                // change status of initial reservation to COMMITED.
                                // This allows grid plugin to notice, that reservation is 
                                // successfully committed.
                                initialReservation.setStatus(Reservation.Status.COMMITTED);
                                return initialReservation;
                        }
                }
                
                return null;
        }


        public List<Reservation> createReservation(ResourceUsage resourceUsage,
                        List<? extends TaskInterface<?>> inExecution,
                        List<Queue<? extends TaskInterface<?>>> queues,
                        ResourceUnitsManagerInterface unitsManager,
                        LocalReservationManager reservManager)
                        throws ReservationException {
                
                LocalReservationManagerImpl reservationManager = (LocalReservationManagerImpl) reservManager;
                TimeResourceAllocation allocation = resourceUsage.get(0);
                
                Reservation reservation = reservationManager.
                                                                        getReservations().add(allocation, Reservation.Status.INITIAL);
                List<Reservation> list = new ArrayList<Reservation>(1);
                list.add(reservation);
                
                return list;
        }

        /*
         * This example implementation puts all new tasks in first queue.
         * Tasks are served in the same order they appear in newTasks list.
         */
        public int placeTasksInQueues(List<? extends TaskInterface<?>> newTasks,
                        List<? extends Queue<? extends TaskInterface<?>>> queues,
                        ResourceUnitsManagerInterface unitsManager,
                        LocalReservationManager reservationManager)
                        throws ReservationException {
                
                // get the first queue from all available queues.
                Queue<? extends TaskInterface<?>> q = queues.get(0);

                // do this trick to enable access to add() method.
                Queue<TaskInterface<?>> queue = (Queue<TaskInterface<?>>) q;
                
                // move tasks from newTask list to the queue.
                for(int i = 0; i < newTasks.size(); i++){
                        TaskInterface<?> task = newTasks.remove(0);
                        queue.add(task);
                }
                return 0;
        }


        public void schedule(SchedulingEvent event,
                        List<? extends TaskInterface<?>> inExecution,
                        List<? extends Queue<? extends TaskInterface<?>>> queues,
                        ResourceUnitsManagerInterface unitsManager,
                        LocalReservationManager reservationManager) {

                // Example implementation move tasks to execution in the same order
                // they appear in task queue.
                
                // choose handle method for event:
                switch(event.getType()){
                        case START_TASK_EXECUTION:
                                // check if reservation is active and, if so, start task execution
                                startTask((StartTaskExecutionEvent)event, inExecution, 
                                                queues, unitsManager, reservationManager);
                                break;
                                
                        case RESERVATION_ACTIVE:
                                // check if task is ready and, if so, start task execution 
                                startTask((ReservationActiveEvent)event, inExecution,
                                                queues, unitsManager, reservationManager);
                                break;
                        
                        case TASK_FINISHED:
                                // if one task is finished, look for next task which can be started
                                startNextTask(inExecution, queues, unitsManager, reservationManager);
                                break;
                
                }
                
        }
        
        /*
         * This method starts task execution. Task can be executed if its status 
         * is READY and reservation created for this task is ACTIVE.
         * Method is called each time task changes its status to READY.
         * 
         * By default, all tasks are placed in first queue - see 
         * BaseLocalARPlugin.placeTasksInQueues() method. 
         */
        protected void startTask(StartTaskExecutionEvent event, 
                        List<? extends TaskInterface<?>> inExecution,
                        List<? extends Queue<? extends TaskInterface<?>>> queues,
                        ResourceUnitsManagerInterface unitsManager,
                        LocalReservationManager reservationManager){

                String jobId = event.getJobId();
                String taskId = event.getTaskId();
                
                List<TaskInterface<?>> execute = (List<TaskInterface<?>>) inExecution;
                Queue<TaskInterface<?>> queue = (Queue<TaskInterface<?>>) queues.get(0);
                
                // In queue, look for task this event corresponds too.
                for(int i = 0; i < queue.size(); i++){
                        TaskInterface<?> task = queue.get(i);
                
                        // check task id, job id and status
                        if(task.getStatus() == Gridlet.READY &&
                                jobId.equals(task.getJobId()) && 
                                taskId.equals(task.getId())){
                                
                                ReservationList reservations = reservationManager.getReservations();
                        
                                // look for the reservation created for the task
                                for(int j = 0; j < reservations.size(); j++){
                                        Reservation r = reservations.get(j);
                                
                                        // check task id, job id and reservation status
                                        if(r.getStatus() == Reservation.Status.ACTIVE &&
                                                        jobId.equals(r.getJobId()) &&
                                                        taskId.equals(r.getTaskId())){
                                                
                                                // try to start task execution
                                                if(execute.add(task)){
                                                        // if executions starts successfully, then remove task from queue
                                                        queue.remove(i);
                                                }
                                                
                                                // return from method, when all job is done.
                                                return;
                                        }
                                }
                        }
                }
        
        }
        
        /*
         * This method starts task execution. Task can be executed if its status 
         * is READY and reservation created for this task is ACTIVE.
         * Method is called each time reservation changes its status to ACTIVE.
         * 
         * By default, all tasks are placed in first queue - see 
         * BaseLocalARPlugin.placeTasksInQueues() method. 
         */
        protected void startTask(ReservationActiveEvent event,
                                List<? extends TaskInterface<?>> inExecution,
                                List<? extends Queue<? extends TaskInterface<?>>> queues,
                                ResourceUnitsManagerInterface unitsManager,
                                LocalReservationManager reservationManager){
        
                String jobId = event.getReservation().getJobId();
                String taskId = event.getReservation().getTaskId();
                
                List<TaskInterface<?>> execute = (List<TaskInterface<?>>) inExecution;
                Queue<TaskInterface<?>> queue = (Queue<TaskInterface<?>>) queues.get(0);
                
                // look for the task, for which this reservation is created
                for(int i = 0; i < queue.size(); i++){
                        TaskInterface<?> task = queue.get(i);
                
                        // check task id, job id and task status
                        if(task.getStatus() == Gridlet.READY &&
                                jobId.equals(task.getJobId()) && 
                                taskId.equals(task.getId())){
                                
                                // try to start task execution
                                if(execute.add(task)){
                                        
                                        // if task execution starts successfully, then remove task from queue
                                        queue.remove(i);
                                }
                                // return from method, when all job is done
                                return;
                        }
                }
        
        }
        
        /*
         * After finish task execution there is place for executing next task.
         * This method looks for READY task which reservation has status ACTIVE
         * and tries to execute it.
         * 
         * Method is called each time task execution is finished.
         */
        protected void startNextTask(List<? extends TaskInterface<?>> inExecution,
                                List<? extends Queue<? extends TaskInterface<?>>> queues,
                                ResourceUnitsManagerInterface unitsManager,
                                LocalReservationManager reservationManager){
        
                List<TaskInterface<?>> execute = (List<TaskInterface<?>>) inExecution;
                Queue<TaskInterface<?>> queue = (Queue<TaskInterface<?>>) queues.get(0);
                
                // for each task in queue
                for(int i = 0; i < queue.size(); i++){
                        TaskInterface<?> task = queue.get(i);
                
                        // look for task with status READY
                        if(task.getStatus() == Gridlet.READY){
                                ReservationList reservations = reservationManager.getReservations();
                        
                                // look for the reservation created for this task
                                for(int j = 0; j < reservations.size(); j++){
                                        Reservation r = reservations.get(j);
                                
                                        // check task id, job id and reservation status
                                        if(r.getStatus() == Reservation.Status.ACTIVE &&
                                                        task.getJobId().equals(r.getJobId()) &&
                                                        task.getId().equals(r.getTaskId())){
                                                
                                                // try to execute this task
                                                if(execute.add(task)){
                                                        
                                                        // if task execution starts successfully, then remove task from queue
                                                        queue.remove(i);
                                                        i--; // modify queue index to get next task correctly
                                                }
                                                
                                                // if reservation is found and all job is done, try to execute next
                                                // READY task
                                                break;
                                        }
                                }
                        }
                }
        }
        
        public SchedulingPluginConfiguration getConfiguration() {
                return DefaultConfiguration.forLocalARPlugin();
        }


        public void schedule(SchedulingEvent event,
                        List<? extends TaskInterface<?>> inExecution,
                        List<? extends Queue<? extends TaskInterface<?>>> queues,
                        ResourceUnitsManagerInterface unitsManager) {
                // do this trick to make add() method available
                List <TaskInterface<?>> execute = (List<TaskInterface<?>>) inExecution;
                
                // chose the events types to serve. 
                // Different actions for different events are possible.
                switch(event.getType()){
                        case START_TASK_EXECUTION:
                        case TASK_FINISHED:
                        //case TIMER:
                                // our tasks are placed only in first queue (see BaseLocalPlugin.placeTasksInQueues() method)
                                Queue<? extends TaskInterface<?>> q = queues.get(0);
                                // check all tasks in queue
                                for(int i = 0; i < q.size(); i++){
                                        TaskInterface<?> task = q.get(i);
                                        // if status of the tasks in READY
                                        
                                        SubmittedTask submittedTask = (SubmittedTask)task;
                                        if(submittedTask.getReservationID() != -1)
                                                continue;
                                        if(task.getStatus() == Gridlet.READY ){
                                                // then try to execute this task. Add it the execute list.
                                                if(execute.add(task)){
                                                        // if task started successfully, then remove it from the queue.
                                                        q.remove(i);
                                                        i--; // index trick to get the right position in the queue after task removal.
                                                }
                                        }
                                }
                                break;
                }
                
        }
        
}