source: xssim/src/gssim/schedframe/resources/QueuingSystemDescription.java @ 104

package gssim.schedframe.resources;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import gridsim.gssim.GssimConstants;
import gridsim.gssim.SubmittedTask;
import gridsim.gssim.resource.ResourceProcessors;
import org.qcg.broker.schemas.exception.NoSuchParamException;
import org.qcg.broker.schemas.exception.UnknownParameter;
import org.qcg.broker.schemas.hostparams.OtherParameterType;
import org.qcg.broker.schemas.hostparams.QueueResource;
import org.qcg.broker.schemas.hostparams.wrapper.QueueResourceParamExplorer;
import org.qcg.broker.schemas.hostparams.wrapper.QueuingSystem;
import org.qcg.broker.schemas.hostparams.wrapper.exception.NotHomogeneous;
import org.qcg.broker.schemas.hostparams.wrapper.impl.ComputingResourceParamExplorerImpl;
import org.qcg.broker.schemas.hostparams.wrapper.impl.QueueResourceParamExplorerImpl;
import gssim.schedframe.scheduling.queues.SubmittedTaskQueue;
import schedframe.resources.ExecutingResourceDescription;
import schedframe.resources.providers.LocalSystem;
import schedframe.resources.units.Cost;
import schedframe.resources.units.Memory;
import schedframe.resources.units.Processor;
import schedframe.resources.units.ResourceUnit;
import schedframe.scheduling.Queue;
import schedframe.scheduling.TaskInterface;


/**
 * 
 * @author Marcin Krystek
 *
 */
public class QueuingSystemDescription extends ExecutingResourceDescription {

        protected Log log = LogFactory.getLog(QueuingSystemDescription.class);
        protected boolean supportReservation;
        
        protected QueuingSystemDescription(){
        };
        
        public QueuingSystemDescription(QueuingSystem nativeDescription){
                
                LocalSystem provider = new LocalSystem();
                provider.setProviderId(nativeDescription.getFrontendId());
                this.provider = provider;
                
                // create resource units
                ResourceProcessors processors = null;
                try {
                        
                        int cpucount = Double.valueOf(nativeDescription.getCpuCnt()).intValue();
                        log.warn("ADD CPU CORE DESCRIPTION SUPPORT FOR QUEUING SYSTEM");
                        
                        
                        int cpuspeed = 1;
                        try {
                                cpuspeed = Double.valueOf(nativeDescription.getCpuSpeed()).intValue();
                        } catch (NoSuchParamException e) {
                                if(log.isWarnEnabled())
                                        log.warn("Queuing system " + nativeDescription.getFrontendId() + 
                                                " cpu speed parameter is not defined, assuming that cpuspeed = "+cpuspeed);
                        } catch (NotHomogeneous e){
                                if(log.isWarnEnabled())
                                        log.warn("Queuing system " + nativeDescription.getFrontendId() + 
                                                " is not homogeneous, therefore spuspeed can not be determined. Assuming default = "+cpuspeed);
                        } catch (UnknownParameter e){
                                if(log.isWarnEnabled())
                                        log.warn("Queuing system  cpu speed parameter is not defined, assuming that cpuspeed = "+cpuspeed);
                        }
                        
                //      Processor exampleProc = new Processor(-1, -1, cpuspeed, null);
                //      processors = new ExecResourceProcessors(null, exampleProc, cpucount, 1, false);
                        log.warn("ADD CPU DISTINGUISH DESCRIPTION SUPPORT FOR QUEUING SYSTEM");

                        addResourceUnit(processors);
                        
                } catch (NoSuchParamException e){
                        if(log.isWarnEnabled())
                                log.warn("Number od cpu's is not defined for " + 
                                                nativeDescription.getFrontendId() + 
                                                " resource. Assuming that cpuCount = 0");
                } catch (UnknownParameter e) {
                        if(log.isWarnEnabled())
                                log.warn("Number od cpu's is not defined for " + 
                                                nativeDescription.getFrontendId() + 
                                                " resource. Assuming that cpuCount = 0");
                }
                
                
                try {
                        
                        int totalMemory = Double.valueOf(nativeDescription.getMemory()).intValue();
                        Memory memory = new Memory(totalMemory, 0);
                        
                        addResourceUnit(memory);
                        
                } catch (NoSuchParamException e) {
                        if(log.isWarnEnabled())
                                log.warn("Queuing system " + 
                                                nativeDescription.getFrontendId() + 
                                                " memory parameter is not defined, assuming that totalMemory = 0");
                } catch (UnknownParameter e) {
                        if(log.isWarnEnabled())
                                log.warn("Queuing system " + 
                                                nativeDescription.getFrontendId() + 
                                                " memory parameter is not defined, assuming that totalMemory = 0");
                }
                
                float c = GssimConstants.DEFAULT_RESOURCE_PROCESSING_COST;
                Cost cost = new Cost(Float.valueOf(c).intValue());
                addResourceUnit(cost);

                
                // create access queues
                
                ComputingResourceParamExplorerImpl frontendExplorer = new ComputingResourceParamExplorerImpl();
                frontendExplorer.explore(nativeDescription.getFrontend());
                supportReservation = false;
                try {
                        OtherParameterType otherParam = frontendExplorer.getOtherParam("reservation");
                        String value = otherParam.getParamValue(0);
                        if("true".equals(value)){
                                supportReservation = true;
                        }
                } catch (NoSuchParamException e) {
                }
                
                processors.enableReservation(supportReservation);
                
                try {
                        QueueResource qu[] = nativeDescription.getQueues();
                        QueueResourceParamExplorer explorer = new QueueResourceParamExplorerImpl();
                        
                        for (int i = 0; i < qu.length; i++) {
                                
                                explorer.explore(qu[i]);
                                int priority = 1;
                                
                                try {
                                        int priorities[] = explorer.getPriority();
                                        priority = new Float(priorities[0]).intValue();
                                        
                                } catch (NoSuchParamException e){
                                        if(log.isErrorEnabled())
                                                log.error("Priority for queue "+ 
                                                                qu[i].getResourceId() + 
                                                                " is not defined. Assuming default priority = " + priority);
                                }
                                
                                String queueName = qu[i].getResourceId();
                                SubmittedTaskQueue queue = new SubmittedTaskQueue(supportReservation);
                                queue.setName(queueName);
                                queue.setPriority(priority);
                                
                                addAccessQueue(queue);
                        }
                        
                } catch(UnknownParameter e){
                        log.error(e.getMessage());
                }
                
        }
        
        public void addResourceUnit(ResourceUnit unit){
                List<ResourceUnit> list = null;
                if(this.resUnits.containsKey(unit.getName())){
                        list = this.resUnits.get(unit.getName());
                } else {
                        list = new ArrayList<ResourceUnit>();
                        this.resUnits.put(unit.getName(), list);
                }
                list.add(unit);

        }
        
        public void addAccessQueue(Queue<SubmittedTask> queue){
                this.accesQueues.add(queue);
        }
        
        public ResourceType getType(){
                return ResourceType.QUEUING_SYSTEM;
        }

        public boolean supportReservation() {
                return supportReservation;
        }
        
        public long getQueueLoad(String queueName) throws NoSuchFieldException{
                int load = 0;
                if(queueName == null){
                        for(Queue<? extends TaskInterface<?>> queue: this.accesQueues){
                                load += queue.size();   
                        }
                        return load;
                }
                else {
                        for(Queue<? extends TaskInterface<?>> queue: this.accesQueues){
                                if(queue.getName().equals(queueName))
                                        return queue.size();
                        }
                }
                throw new NoSuchFieldException("Queue " + queueName + 
                                                " is not available in resource " + provider.getProviderId());

        }
        
}