source: xssim/src/schedframe/resources/ExecutingResourceDescription.java @ 104

package schedframe.resources;

import gridsim.gssim.resource.ResourceProcessors;
import org.qcg.broker.schemas.exception.NoSuchParamException;
import org.qcg.broker.schemas.hostparams.ComputingResourceParameterType;
import org.qcg.broker.schemas.hostparams.Property;
import org.qcg.broker.schemas.hostparams.types.ComputingParameterName;
import org.qcg.broker.schemas.hostparams.wrapper.impl.ComputingResourceParamExplorerImpl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

import schedframe.resources.units.Processor;
import schedframe.scheduling.Queue;
import schedframe.scheduling.TaskInterface;

/**
 * 
 * @author Marcin Krystek
 *
 */
public abstract class ExecutingResourceDescription extends ResourceDescription {

        private Log log = LogFactory.getLog(ExecutingResourceDescription.class);
        
        protected List<Queue<? extends TaskInterface<?>>> accesQueues;
        
        protected Map<String, PowerInterface> nodesPowerProfilesMap;
        
        public ExecutingResourceDescription(){
                this.accesQueues = new ArrayList<Queue<? extends TaskInterface<?>>>();
                this.nodesPowerProfilesMap = new HashMap<String, PowerInterface>();
        }
        
        /**
         * 
         * @return list of queues. These are the queues in which tasks submitted
         * to this resource are waiting for local scheduling decision
         */
        public List<Queue<? extends TaskInterface<?>>> getAccessQueues(){
                return this.accesQueues;
        }
        
        protected int getCorecountParameterValue(ComputingResourceParamExplorerImpl explorer){
                
                try {
                        
                        ComputingResourceParameterType paramType = explorer.getHostParam(ComputingParameterName.CPUCOUNT);
                        Property properties[] = paramType.getProperty();
                        for(int j = 0; j < properties.length; j++){
                                Property p = properties[j];
                                String name = p.getName();
                                if("corecount".equalsIgnoreCase(name)){
                                        int count = Integer.parseInt(p.getValue(0));
                                        System.out.println("corecount: " + count);
                                        return count;
                                } 
                        }

                } catch (NoSuchParamException e) {
                        log.error(e.getMessage());
                }
                                
                return 1;
        }
        
        protected String getPropertyValue(ComputingResourceParameterType paramType, String propertyName){
                        
                Property properties[] = paramType.getProperty();
                for(int j = 0; j < properties.length; j++){
                        Property p = properties[j];
                        String name = p.getName();
                        if(propertyName.equalsIgnoreCase(name)){
                                return p.getValue(0);
                        }
                }

                return null;
        }
        
        public Map<String, PowerInterface> getNodePowerProfiles(){
                return this.nodesPowerProfilesMap;
        }
        
        public abstract boolean supportReservation();
        
        protected class ExecResourceProcessors extends ResourceProcessors{

                public ExecResourceProcessors(String resId, Processor p,
                                                                        int cpuCnt, int coreCnt, boolean uniqe) {
                        super(resId);
                        this.areUnique = uniqe;
                        this.processors = new ArrayList<Processor>(cpuCnt * coreCnt);
                        
                        for(int i = 0; i < cpuCnt; i++){
                                for(int j = 0; j < coreCnt; j++){
                                        Processor cpu = new Processor(i, j);
                                        cpu.setComputingNodeId(p.getComputingNodeId());
                                        cpu.accept(p.getPowerProfile().clone());
                                        this.processors.add(cpu);
                                }
                        }
                }
                
        }
}